motor-admin 0.3.3 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2381b665cf63ac72903b322e652a119c154215db95b477e4f723eb4c0bbdf97
-  data.tar.gz: 44ffba20a1acb4206a43abfba8ab58c36cb7fd5ff421926c06347f2df3e7a168
+  metadata.gz: eda6baf4fb621527782a8529725aa8b8d794a95e17739f657d8ce03bc377de65
+  data.tar.gz: 262bceb177a009a497c84ba318254efe97894d474c98d3fcb3c34d35581d05a9
 SHA512:
-  metadata.gz: 3f9c1360a6d42da64df2bfeed16d2765aef367ec535d3469d91b3093e3f12ab640fd72c13f76bc8e26dbccad1813c7583c7fce9d81dd8c725c79cbde92d6df97
-  data.tar.gz: 17daf2ac024c72d6614ea8fa21814c7f224d325f6f8872d1e8df4bbc54bdfe1019622e6c4570821bb17588645010c3b1e126e4865ca056ba62c492294f3e6202
+  metadata.gz: 9b7500eb106243d61258e8c244a62c6a7cf0b70727a2a69c401fd727a49f7922b1d2e0df097e5ac6c5ba5c6ca176fedc95c46dee873b1308cf9445122ce2f7e1
+  data.tar.gz: 8fdaa674012474e2db6fd95679476aa0ebbf59bfb2d54589e5816d819b4ec6b327c43929a832bccc969b161e90a5efad59246dc68db9e9944c21cac1244b73c9

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
+
+module Arel
+  module Attributes
+    class Relation < Attribute
+      attr_accessor :collection, :for_write
+
+      def initialize(relation, name, collection = false, for_write = false)
+        self[:relation] = relation
+        self[:name] = name
+        @collection = collection
+        @for_write = for_write
+      end
+
+      delegate :able_to_type_cast?, to: :relation
+
+      def table_name
+        nil
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          relation == other.relation &&
+          name == other.name &&
+          collection == other.collection
+      end
+
+      delegate :type_cast_for_database, to: :relation
+    end
+  end
+end
+
+module Arel
+  module Visitors
+    class ToSql
+      def visit_Arel_Attributes_Relation(o, collector)
+        visit(o.relation, collector)
+      end
+    end
+  end
+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 :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/queries/run_query.rb

@@ -195,7 +195,7 @@ module Motor
                                       sql.gsub(STATEMENT_VARIABLE_REGEXP, '?'),
                                       attributes.map(&:value))
 
-        [sql, 'SQL', attributes]
+        [sql, 'SQL', []]
       end
 
       def normalize_sql(sql)

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.3'
+  VERSION = '0.3.6'
 end

data/lib/motor.rb

@@ -6,7 +6,6 @@ require 'cancancan'
 require 'ar_lazy_preload'
 require 'fugit'
 require 'csv'
-require 'active_record/filter'
 require 'audited'
 require 'uri'
 require 'net/http'

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: motor-admin
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.6
 platform: ruby
 authors:
 - Pete Matsyburka
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-29 00:00:00.000000000 Z
+date: 2022-08-10 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activerecord-filter
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: ar_lazy_preload
   requirement: !ruby/object:Gem::Requirement
@@ -86,14 +72,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 +157,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