motor-admin 0.3.4 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b64a0a9d826bc1625ad7e0423176f37781388b71beeba438bf3b964961208c55
-  data.tar.gz: 82c10707400ab8c452e728dda5d8cb5219fbc2339b0dd9cb020e2607a2c9045a
+  metadata.gz: ce4fa10d33b3f41a5a0ba509b53d7815631c1980b521839ecc51f7f80ed548aa
+  data.tar.gz: 35d3b13d657714f909ab7fc56f088fc3270b0e40e1839aadc5cf227c99e78fc2
 SHA512:
-  metadata.gz: e5688351835e69c2c3ccdfb096a0dc2abb16638ce8fe18810517a0a278cef7e7a74bf406e48bf8ce2be47cd6b9b65b5455ac4ab2c0ef868683fc5cbedced125c
-  data.tar.gz: 2f3f1f8e709d4f10767ade44a5495ef136d57a18a1cc70e4b4f0e92a0afb6629ef7ed8cdb884147f2037e6a7eb97e0bb792f4063bb5bf9664b150ba2702aa4bd
+  metadata.gz: b6c79c98ff08d7402cfc54ff91c661616f2b87bced25af12ff0637a99327fdb000455e9bd32fd78ffe611e3007acfd01104f74b39f5318a1dcdf2798151db733
+  data.tar.gz: ba7f58cfd0500b1aa6b9f7b7659afd718f05b548da8597384cc2d036b08c1d4a54c5aa291ddb05b9ebda05cb65bdf08d3bc19e6c6d553d9ab12b3bb0b12dd437

data/lib/motor/active_record_utils/active_record_filter.rb

@@ -0,0 +1,400 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class UnkownFilterError < NoMethodError
+  end
+end
+
+ActiveRecord::QueryMethods.module_eval do
+  def build_arel_with_distinct_on(aliases = nil)
+    arel = build_arel_without_distinct_on(aliases)
+    arel.distinct_on(distinct_on_values) unless distinct_on_values.empty?
+    arel
+  end
+
+  alias_method :build_arel, :build_arel_with_distinct_on
+end
+
+module ActiveRecord
+  module Associations
+    class AliasTracker
+      def initialize(connection, aliases)
+        @aliases    = aliases
+        @connection = connection
+        @relation_trail = {}
+      end
+
+      def aliased_table_for_relation(trail, arel_table, &block)
+        @relation_trail[trail] ||= aliased_table_for(arel_table, &block)
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  class PredicateBuilder # :nodoc:
+    def self.filter_joins(klass, filters)
+      custom = []
+      [build_filter_joins(klass, filters, [], custom), custom]
+    end
+
+    def self.build_filter_joins(klass, filters, relations = [], custom = [])
+      case filters
+      when Array
+        filters.each { |f| build_filter_joins(klass, f, relations, custom) }.compact
+      when Hash
+        filters.each do |key, value|
+          if klass.respond_to?(:filters) && klass.filters.key?(key.to_sym)
+            js = klass.filters.dig(key.to_sym, :joins)
+
+            if js.is_a?(Array)
+              js.each do |j|
+                if j.is_a?(String)
+                  custom << j
+                else
+                  relations << j
+                end
+              end
+            elsif js
+              if js.is_a?(String)
+                custom << js
+              else
+                relations << js
+              end
+            end
+          elsif reflection = klass._reflections[key.to_s]
+            if value.is_a?(Hash)
+              relations << if reflection.polymorphic?
+                             value = value.dup
+                             join_klass = value.delete(:as).safe_constantize
+                             right_table = join_klass.arel_table
+                             left_table = reflection.active_record.arel_table
+
+                             on = right_table[join_klass.primary_key]
+                                  .eq(left_table[reflection.foreign_key])
+                                  .and(left_table[reflection.foreign_type].eq(join_klass.name))
+
+                             cross_boundry_joins = join_klass.left_outer_joins(ActiveRecord::PredicateBuilder.filter_joins(join_klass, value).flatten).send(
+                               :build_joins, []
+                             )
+
+                             [
+                               left_table.join(right_table, Arel::Nodes::OuterJoin).on(on).join_sources,
+                               cross_boundry_joins
+                             ]
+                           else
+                             {
+                               key => build_filter_joins(reflection.klass, value, [], custom)
+                             }
+                           end
+            elsif value.is_a?(Array)
+              value.each do |v|
+                relations << {
+                  key => build_filter_joins(reflection.klass, v, [], custom)
+                }
+              end
+            elsif value != true && value != false && value != 'true' && value != 'false' && !value.nil?
+              relations << key
+            end
+          elsif !klass.columns_hash.key?(key.to_s) && key.to_s.end_with?('_ids') && reflection = klass._reflections[key.to_s.gsub(
+            /_ids$/, 's'
+          )]
+            relations << reflection.name
+          elsif reflection = klass.reflect_on_all_associations(:has_and_belongs_to_many).find do |r|
+                  r.join_table == key.to_s && value.keys.first.to_s == r.association_foreign_key.to_s
+                end
+            reflection = klass._reflections[klass._reflections[reflection.name.to_s].send(:delegate_reflection).options[:through].to_s]
+            relations << { reflection.name => build_filter_joins(reflection.klass, value) }
+          end
+        end
+      end
+
+      relations
+    end
+
+    def build_from_filter_hash(attributes, relation_trail, alias_tracker)
+      case attributes
+      when Array
+        node = build_from_filter_hash(attributes.shift, relation_trail, alias_tracker)
+
+        n = attributes.shift(2)
+        until n.empty?
+          n[1] = build_from_filter_hash(n[1], relation_trail, alias_tracker)
+          if n[0] == 'AND'
+            if node.is_a?(Arel::Nodes::And)
+              node.children.push(n[1])
+            else
+              node = node.and(n[1])
+            end
+          elsif n[0] == 'OR'
+            node = Arel::Nodes::Grouping.new(node).or(Arel::Nodes::Grouping.new(n[1]))
+          elsif !n[0].is_a?(String)
+            n[0] = build_from_filter_hash(n[0], relation_trail, alias_tracker)
+            if node.is_a?(Arel::Nodes::And)
+              node.children.push(n[0])
+            else
+              node = node.and(n[0])
+            end
+          else
+            raise 'lll'
+          end
+          n = attributes.shift(2)
+        end
+
+        node
+      when Hash
+        expand_from_filter_hash(attributes, relation_trail, alias_tracker)
+      else
+        expand_from_filter_hash({ id: attributes }, relation_trail, alias_tracker)
+      end
+    end
+
+    def expand_from_filter_hash(attributes, relation_trail, alias_tracker)
+      klass = table.send(:klass)
+
+      children = attributes.flat_map do |key, value|
+        if klass.respond_to?(:filters) && custom_filter = klass.filters[key]
+          instance_exec(klass, table, key, value, relation_trail, alias_tracker, &custom_filter[:block])
+        elsif column = klass.columns_hash[key.to_s] || klass.columns_hash[key.to_s.split('.').first]
+          expand_filter_for_column(key, column, value, relation_trail)
+        elsif relation = klass.reflect_on_association(key)
+          expand_filter_for_relationship(relation, value, relation_trail, alias_tracker)
+        elsif key.to_s.end_with?('_ids') && relation = klass.reflect_on_association(key.to_s.gsub(/_ids$/, 's'))
+          expand_filter_for_relationship(relation, { id: value }, relation_trail, alias_tracker)
+        elsif relation = klass.reflect_on_all_associations(:has_and_belongs_to_many).find do |r|
+                r.join_table == key.to_s && value.keys.first.to_s == r.association_foreign_key.to_s
+              end
+          expand_filter_for_join_table(relation, value, relation_trail, alias_tracker)
+        else
+          raise ActiveRecord::UnkownFilterError, "Unkown filter \"#{key}\" for #{klass}."
+        end
+      end
+
+      children.compact!
+      if children.size > 1
+        Arel::Nodes::And.new(children)
+      else
+        children.first
+      end
+    end
+
+    def expand_filter_for_column(key, column, value, relation_trail)
+      attribute = table.arel_table[column.name]
+      relation_trail.each do |rt|
+        attribute = Arel::Attributes::Relation.new(attribute, rt)
+      end
+
+      if column.type == :json || column.type == :jsonb
+        names = key.to_s.split('.')
+        names.shift
+        attribute = attribute[names]
+      end
+
+      if value.is_a?(Hash)
+        nodes = value.map do |subkey, subvalue|
+          expand_filter_for_arel_attribute(column, attribute, subkey, subvalue)
+        end
+        nodes.inject { |c, n| c.nil? ? n : c.and(n) }
+      elsif value.nil?
+        attribute.eq(nil)
+      elsif [true, 'true'].include?(value)
+        column.type == :boolean ? attribute.eq(true) : attribute.not_eq(nil)
+      elsif [false, 'false'].include?(value)
+        column.type == :boolean ? attribute.eq(false) : attribute.eq(nil)
+      elsif value.is_a?(Array) && !column.array
+        attribute.in(value)
+      elsif column.type != :json && column.type != :jsonb
+        converted_value = column.array ? Array(value) : value
+        attribute.eq(converted_value)
+      else
+        raise ActiveRecord::UnkownFilterError, "Unkown type for #{column}. (type #{value.class})"
+      end
+    end
+
+    def expand_filter_for_arel_attribute(column, attribute, key, value)
+      case key.to_sym
+      when :contains
+        attribute.contains(Arel::Nodes::Casted.new(column.array ? Array(value) : value, attribute))
+      when :contained_by
+        attribute.contained_by(Arel::Nodes::Casted.new(column.array ? Array(value) : value, attribute))
+      when :equal_to, :eq
+        attribute.eq(value)
+      when :excludes
+        attribute.excludes(Arel::Nodes::Casted.new(column.array ? Array(value) : value, attribute))
+      when :greater_than, :gt
+        attribute.gt(value)
+      when :greater_than_or_equal_to, :gteq, :gte
+        attribute.gteq(value)
+      when :has_key
+        attribute.has_key(value)
+      when :has_keys
+        attribute.has_keys(*Array(value).map { |x| Arel::Nodes.build_quoted(x) })
+      when :has_any_key
+        attribute.has_any_key(*Array(value).map { |x| Arel::Nodes.build_quoted(x) })
+      when :in
+        attribute.in(value)
+      when :intersects
+        # geometry_value = if value.is_a?(Hash) # GeoJSON
+        #   Arel::Nodes::NamedFunction.new('ST_GeomFromGeoJSON', [JSON.generate(value)])
+        # elsif # EWKB
+        # elsif # WKB
+        # elsif # EWKT
+        # elsif # WKT
+        # end
+
+        # TODO: us above if to determin if SRID sent
+        geometry_value = if value.is_a?(Hash)
+                           Arel::Nodes::NamedFunction.new('ST_SetSRID',
+                                                          [
+                                                            Arel::Nodes::NamedFunction.new('ST_GeomFromGeoJSON',
+                                                                                           [Arel::Nodes.build_quoted(JSON.generate(subvalue))]), 4326
+                                                          ])
+                         elsif value[0, 1] == "\x00" || value[0, 1] == "\x01" || value[0, 4] =~ /[0-9a-fA-F]{4}/
+                           Arel::Nodes::NamedFunction.new('ST_SetSRID',
+                                                          [
+                                                            Arel::Nodes::NamedFunction.new('ST_GeomFromEWKB',
+                                                                                           [Arel::Nodes.build_quoted(subvalue)]), 4326
+                                                          ])
+                         else
+                           Arel::Nodes::NamedFunction.new('ST_SetSRID',
+                                                          [
+                                                            Arel::Nodes::NamedFunction.new('ST_GeomFromText',
+                                                                                           [Arel::Nodes.build_quoted(subvalue)]), 4326
+                                                          ])
+                         end
+
+        Arel::Nodes::NamedFunction.new('ST_Intersects', [attribute, geometry_value])
+      when :less_than, :lt
+        attribute.lt(value)
+      when :less_than_or_equal_to, :lteq, :lte
+        attribute.lteq(value)
+      when :like
+        attribute.matches(value, nil, true)
+      when :ilike
+        attribute.matches(value, nil, false)
+      when :not, :not_equal, :neq
+        attribute.not_eq(value)
+      when :not_in
+        attribute.not_in(value)
+      when :overlaps
+        attribute.overlaps(Arel::Nodes::Casted.new(column.array ? Array(value) : value, attribute))
+      when :not_overlaps
+        attribute.not_overlaps(value)
+      when :ts_match
+        if value.is_a?(Array)
+          attribute.ts_query(*value)
+        else
+          attribute.ts_query(value)
+        end
+      when :within
+        case value
+        when String
+          if /\A[0-9A-F]*\Z/i.match?(value) && value.start_with?('00', '01')
+            attribute.within(Arel::Nodes::HexEncodedBinary.new(value))
+          else
+            attribute.within(Arel::Nodes.build_quoted(value))
+          end
+        when Hash
+          attribute.within(Arel::Nodes.build_quoted(value))
+        else
+          raise "Not Supported value for within: #{value.inspect}"
+        end
+      else
+        raise "Not Supported: #{key.to_sym} on column \"#{column.name}\" of type #{column.type}"
+      end
+    end
+
+    def expand_filter_for_relationship(relation, value, relation_trail, alias_tracker)
+      case relation.macro
+      when :has_many
+        case value
+        when true, 'true'
+          counter_cache_column_name = relation.counter_cache_column || "#{relation.plural_name}_count"
+          if relation.active_record.column_names.include?(counter_cache_column_name.to_s)
+            return table.arel_table[counter_cache_column_name.to_sym].gt(0)
+          else
+            raise "Not Supported: #{relation.name}"
+          end
+        when false, 'false'
+          counter_cache_column_name = relation.counter_cache_column || "#{relation.plural_name}_count"
+          if relation.active_record.column_names.include?(counter_cache_column_name.to_s)
+            return table.arel_table[counter_cache_column_name.to_sym].eq(0)
+          else
+            raise "Not Supported: #{relation.name}"
+          end
+        end
+
+      when :belongs_to
+        if [true, 'true'].include?(value)
+          return table.arel_table[relation.foreign_key].not_eq(nil)
+        elsif value == false || value == 'false' || value.nil?
+          return table.arel_table[relation.foreign_key].eq(nil)
+        end
+      end
+
+      if relation.polymorphic?
+        value = value.dup
+        klass = value.delete(:as).safe_constantize
+
+        builder = self.class.new(TableMetadata.new(
+                                   klass,
+                                   alias_tracker.aliased_table_for_relation(relation_trail + ["#{klass.table_name}_as_#{relation.name}"],
+                                                                            klass.arel_table) do
+                                     klass.arel_table.name
+                                   end,
+                                   relation
+                                 ))
+        builder.build_from_filter_hash(value, relation_trail + ["#{klass.table_name}_as_#{relation.name}"],
+                                       alias_tracker)
+      else
+        builder = self.class.new(TableMetadata.new(
+                                   relation.klass,
+                                   alias_tracker.aliased_table_for_relation(relation_trail + [relation.name],
+                                                                            relation.klass.arel_table) do
+                                     relation.alias_candidate(table.arel_table.name || relation.klass.arel_table)
+                                   end,
+                                   relation
+                                 ))
+        builder.build_from_filter_hash(value, relation_trail + [relation.name], alias_tracker)
+      end
+    end
+
+    def expand_filter_for_join_table(relation, value, relation_trail, alias_tracker)
+      relation = relation.active_record._reflections[relation.active_record._reflections[relation.name.to_s].send(:delegate_reflection).options[:through].to_s]
+      builder = self.class.new(TableMetadata.new(
+                                 relation.klass,
+                                 alias_tracker.aliased_table_for_relation(relation_trail + [relation.name],
+                                                                          relation.klass.arel_table) do
+                                   relation.alias_candidate(table.arel_table.name || relation.klass.arel_table)
+                                 end,
+                                 relation
+                               ))
+      builder.build_from_filter_hash(value, relation_trail + [relation.name], alias_tracker)
+    end
+  end
+end
+
+module ActiveRecord
+  class Relation
+    class FilterClauseFactory # :nodoc:
+      def initialize(klass, predicate_builder)
+        @klass = klass
+        @predicate_builder = predicate_builder
+      end
+
+      def build(filters, alias_tracker)
+        if filters.is_a?(Hash) || filters.is_a?(Array)
+          parts = [predicate_builder.build_from_filter_hash(filters, [], alias_tracker)]
+        else
+          raise ArgumentError, "Unsupported argument type: #{filters.inspect} (#{filters.class})"
+        end
+
+        WhereClause.new(parts)
+      end
+
+      protected
+
+      attr_reader :klass, :predicate_builder
+    end
+  end
+end

data/lib/motor/active_record_utils.rb

@@ -40,6 +40,6 @@ require_relative './active_record_utils/fetch_methods'
 require_relative './active_record_utils/defined_scopes_extension'
 require_relative './active_record_utils/active_storage_links_extension'
 require_relative './active_record_utils/active_storage_blob_patch'
-require_relative './active_record_utils/active_record_filter_patch'
+require_relative './active_record_utils/active_record_filter'
 require_relative './active_record_utils/active_record_connection_column_patch'
 require_relative './active_record_utils/action_text_attribute_patch'

data/lib/motor/api_query/build_meta.rb

@@ -8,7 +8,10 @@ module Motor
       def call(rel, params)
         meta = {}
 
-        meta[:count] = rel.limit(nil).offset(nil).reorder(nil).count if params[:meta].to_s.include?('count')
+        if params[:meta].to_s.include?('count')
+          meta[:count] =
+            rel.limit(nil).offset(nil).reorder(nil).select(rel.klass.arel_table[rel.klass.primary_key]).count
+        end
 
         meta
       end

data/lib/motor/api_query/filter.rb

@@ -13,12 +13,57 @@ module Motor
 
         normalized_params = normalize_params(Array.wrap(params))
 
-        rel = rel.filter(normalized_params)
+        rel = apply_filters(rel, normalized_params)
         rel = rel.distinct if can_apply_distinct?(rel)
 
         rel
       end
 
+      def clean_filters(value)
+        if value.class.name == 'ActionController::Parameters'
+          value.to_unsafe_h
+        elsif value.is_a?(Array)
+          value.map { |v| clean_filters(v) }
+        else
+          value
+        end
+      end
+
+      def apply_predicates(rel, filters)
+        joins = ActiveRecord::PredicateBuilder.filter_joins(rel.klass, filters)
+
+        joins.flatten.reduce(rel) do |acc, j|
+          if j.is_a?(String) || j.is_a?(Arel::Nodes::Join)
+            acc.joins(j)
+          elsif j.present?
+            acc.left_outer_joins(j)
+          else
+            acc
+          end
+        end
+      end
+
+      def apply_filters(rel, filters)
+        filters = clean_filters(filters)
+
+        rel = apply_predicates(rel, filters)
+
+        alias_tracker = ActiveRecord::Associations::AliasTracker.create(rel.connection, rel.table.name, [])
+        filter_clause_factory = ActiveRecord::Relation::FilterClauseFactory.new(rel.klass, rel.predicate_builder)
+
+        where_clause = filter_clause_factory.build(filters, alias_tracker)
+
+        rel_values = rel.instance_variable_get(:@values)
+
+        if rel_values[:where]
+          rel_values[:where] += where_clause
+        else
+          rel_values[:where] = where_clause
+        end
+
+        rel
+      end
+
       def normalize_params(params)
         params.map do |item|
           next item if item.is_a?(String)

data/lib/motor/resources/fetch_configured_model.rb

@@ -191,7 +191,9 @@ module Motor
         if options[:class_name] == 'ActiveStorage::Attachment'
           klass.has_many_attached name.delete_suffix('_attachments').to_sym
         elsif filters.present?
-          klass.has_many(name.to_sym, -> { filter(filters).tap(&:arel) }, **options.symbolize_keys)
+          klass.has_many(name.to_sym, lambda {
+                                        Motor::ApiQuery::Filter.apply_filters(all, filters).distinct
+                                      }, **options.symbolize_keys)
         else
           klass.has_many(name.to_sym, **options.symbolize_keys)
         end

data/lib/motor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Motor
-  VERSION = '0.3.4'
+  VERSION = '0.3.5'
 end

data/lib/motor.rb

@@ -6,11 +6,11 @@ require 'cancancan'
 require 'ar_lazy_preload'
 require 'fugit'
 require 'csv'
-require 'active_record/filter'
 require 'audited'
 require 'uri'
 require 'net/http'
 require 'net/https'
+require 'arel/extensions'
 
 module Motor
   PATH = Pathname.new(__dir__)

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: motor-admin
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
 platform: ruby
 authors:
 - Pete Matsyburka
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-03 00:00:00.000000000 Z
+date: 2022-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activerecord-filter
+  name: arel-extensions
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: ar_lazy_preload
   requirement: !ruby/object:Gem::Requirement
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: '6.0'
 description: |
   Motor Admin allows to create a flexible admin panel with writing less code.
   All customizations to the admin panel can be made directly in the UI without
@@ -171,7 +171,7 @@ files:
 - lib/motor/active_record_utils.rb
 - lib/motor/active_record_utils/action_text_attribute_patch.rb
 - lib/motor/active_record_utils/active_record_connection_column_patch.rb
-- lib/motor/active_record_utils/active_record_filter_patch.rb
+- lib/motor/active_record_utils/active_record_filter.rb
 - lib/motor/active_record_utils/active_storage_blob_patch.rb
 - lib/motor/active_record_utils/active_storage_links_extension.rb
 - lib/motor/active_record_utils/defined_scopes_extension.rb

data/lib/motor/active_record_utils/active_record_filter_patch.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-ActiveRecord::Filter.module_eval do
-  def filters
-    @filters ||= HashWithIndifferentAccess.new
-  end
-end
-
-if Rails::VERSION::MAJOR == 6
-  ActiveRecord::Relation::Filter.module_eval do
-    def build_arel(aliases = nil)
-      arel = super
-      my_alias_tracker = ActiveRecord::Associations::AliasTracker.create(connection, table.name, [])
-      build_filters(arel, my_alias_tracker)
-      arel
-    end
-
-    def build_filters(manager, alias_tracker)
-      return unless @filters
-
-      where_clause = nil
-
-      @filters.each do |filters|
-        where_clause = filter_clause_factory.build(filters, alias_tracker)
-
-        manager.where(where_clause.ast)
-      end
-
-      @values[:where] = where_clause if where_clause
-    end
-  end
-end