active_hash_relation 1.2.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a59228314ab4ecac89c7ba2f988514e453d2b434
-  data.tar.gz: 16316aba61f2ff203189607d69fd9e738649187d
+  metadata.gz: 3ba8d3aaed9463815f83717410dabf1d47fd2959
+  data.tar.gz: 14e4eea13e73d7f60ada9f9313a0739e3311fb0f
 SHA512:
-  metadata.gz: 67342eb6d946bea38b57f1b3e1f99f389c815fef0f6c89445c806ccde2750b18b33810d8cf60ac7b982281de08ad3564f329147d9d6b18be31070345a64f445e
-  data.tar.gz: aa938f3c84a0054be00d9af1fe80cda17ef4a9e0f249bd4d91a23d065230d3052cb7f8da81a215171d54e4226c959bc0fe7cefad328be807ea0977f914e27998
+  metadata.gz: 608d20958f7fd3f37e121abbe57c7c4aa546af10112edcd27e47cbc05f0e702139e6cc23e3bced226c7af8eee354d886b779ffb7c7cd385b639d063c7609ad35
+  data.tar.gz: ebfd652d954d006b0fc13eb4b4b146f95dce213821d52a78f661f7b1a5a80f2a3a9f6723893c5440fae771526bbf45afb36348b47b8d329ef1b0f24db1c781d4

data/README.md

@@ -1,36 +1,38 @@
 # ActiveHashRelation
 [ ![Codeship Status for kollegorna/active_hash_relation](https://app.codeship.com/projects/02f08850-cc66-0134-028f-5ad72e690a75/status?branch=master)](https://app.codeship.com/projects/200194)
 
+ActiveHashRelation is a complete substitute of ActiveRecord::Relation that allows you to run ActiveRecord queries using only regular Hash using a very powerful yet simple API. It was initially built to allow front-end teams to specify from the API exactly what they need withoug bugging the backend developers, eventually emerged into its own little gem.
+
 ## Introduction
 Simple gem that allows you to manipulate ActiveRecord::Relation using JSON. For instance:
 ```ruby
-apply_filters(resource, {name: 'RPK', id: [1,2,3,4,5,6,7,8,9], start_date: {leq: "2014-10-19"}, act_status: "ongoing"})
+apply_filters(User.all, {name: 'filippos', created_at: {leq: "2016-10-19"}, role: 'regular', email: {like: 'vasilakis'}})
 ```
-filter a resource based on it's associations:
+filter a resource based on it's associations using a NOT filter:
 ```ruby
-apply_filters(resource, {updated_at: { geq: "2014-11-2 14:25:04"}, unit: {id: 9})
+apply_filters(Microposts.all, {updated_at: { geq: "2014-11-2 14:25:04"}, user: {not: {email: vasilakisfil@gmail.com}})
 ```
-or even filter a resource based on it's associations' associations:
+or even filter a resource based on it's associations' associations using an OR filter:
 ```ruby
-apply_filters(resource, {updated_at: { geq: "2014-11-2 14:25:04"}, unit: {id: 9, areas: {or: [{id: 22}, {id: 21}]} }})
+apply_filters(Comments.all, {updated_at: { geq: "2014-11-2 14:25:04"}, user: {id: 9, units: {or: [{id: 22}, {id: 21}]} }})
 ```
-and the list could go on.. Basically your whole db is exposed\* there. It's perfect for filtering a collection of resources on APIs.
+and the list could go on.. Basically you can run anything ActiveRecord supports, except from groupping. It's perfect for filtering a collection of resources on APIs.
 
 It should be noted that `apply_filters` calls `ActiveHashRelation::FilterApplier` class
 underneath with the same params.
 
-_\*Actually nothing is exposed, but a user could retrieve resources based
+You can also do [__aggregation queries__](#aggregation-queries), like `sum`, `avg`, `min` and `max` on any column.
+
+_\*A user could retrieve resources based
 on unknown attributes (attributes not returned from the API) by brute forcing
-which might or might not be a security issue. If you don't like that check
-[whitelisting](#whitelisting)._
+which might or might not be a security issue. If you don't like that check you can specify from the `params` exactly what is allowed and what is not allowed. For more information check: [whitelisting](#whitelisting)._
 
-*New*! You can now do [__aggregation queries__](#aggregation-queries).
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'active_hash_relation', '~> 1.2.0
+    gem 'active_hash_relation', '~> 1.3.0
 
 And then execute:
 
@@ -61,7 +63,8 @@ class Api::V1::ResourceController < Api::V1::BaseController
 end
 ```
 
-If you **need to enable filtering on scopes**, you need to specify that explicitly from the initializer. For instance:
+If you **need to enable filtering on scopes**, you need to specify that explicitly from the initializer. Please run:
+`bundle exec rails g active_hash_relation:initialize` which will create an initializer with the following content:
 
 ```ruby
 ActiveHashRelation.configure do |config|
@@ -79,6 +82,7 @@ end
   #requires monkeyparched scopes, optional if you don't enable them
   ActiveHashRelation.initialize!
 ```
+If you are not using Rails, just add the code above in your equivelant initialize block.
 
 ## The API
 ### Columns
@@ -140,8 +144,20 @@ However I would strongly advice you to use a pagination gem like Kaminari, and u
 
 
 ### Sorting
+You can apply sorting using the property as the key of the hash and order as the value. For instance:
+* `{sort: {created_at: desc}}`
+
+You can also order by multiple attributes:
+* `{sort: {created_at: desc, microposts_count: :asc}}`
+
+If there is no column named after the property value, sorting is skipped.
+
+#### Deprecated API (will be removed in version 2.0)
 You can apply sorting using the `property` and `order` attributes. For instance:
-* `{sort: {property: 'created_at', order: 'desc'}}`
+* `{sort: {property: :created_at, order: :desc}}`
+
+You can also order by multiple attributes:
+* `{sort: [{property: :created_at, order: :desc}, {property: :created_at, order: :desc}]}`
 
 If there is no column named after the property value, sorting is skipped.
 
@@ -174,8 +190,21 @@ You can apply an `OR` on associations as well or even nested ones, there isn't m
 I suggest you though to take a look on the [tests](spec/tests/or_filter_spec.rb), cause the syntax gets a bit complex after a while ;)
 
 
+### NOT Filter
+You can apply an SQL `NOT` (for ActiveRecord 4+) using the following syntax:
+`{not: {name: 'Filippos', email: {ends_with: '@gmail.com'}}}`
+
+It will generate: `WHERE (NOT (users.name = 'Filippos')) AND (NOT (users.email LIKE '%@gmail.com'))`
+
+You can apply an `NOT` on associations as well or even nested ones, there isn't much limitation on that.
+I suggest you to also take a look on the [tests](spec/tests/not_filter_spec.rb).
+
+Also I should note that you need to add specific (partial) queries if you don't want
+to have performance issues on tables with millions of rows.
+
+
 ### Scopes
-**Filtering on scopes is not enabled by default**.
+**Filtering on scopes is not enabled by default. You need to add the initializer mentioned in the beginning of the [How to use](#how-to-use) section.**.
 
 Scopes are supported via a tiny monkeypatch in the ActiveRecord's scope class method which holds the name of each scope.
 The monkey patch is as gentle as it can be: it aliases the method, adds some sugar and executes it.

data/lib/active_hash_relation/column_filters.rb

@@ -2,7 +2,11 @@ module ActiveHashRelation::ColumnFilters
   def filter_integer(resource, column, table_name, param)
     if param.is_a? Array
       n_param = param.to_s.gsub("\"","'").gsub("[","").gsub("]","") #fix this!
-      return resource.where("#{table_name}.#{column} IN (#{n_param})")
+      if @is_not
+        return resource.where.not("#{table_name}.#{column} IN (#{n_param})")
+      else
+        return resource.where("#{table_name}.#{column} IN (#{n_param})")
+      end
     elsif param.is_a? Hash
       if !param[:null].nil?
         return null_filters(resource, table_name, column, param)
@@ -10,7 +14,11 @@ module ActiveHashRelation::ColumnFilters
         return apply_leq_geq_le_ge_filters(resource, table_name, column, param)
       end
     else
-      return resource.where("#{table_name}.#{column} = ?", param)
+      if @is_not
+        return resource.where.not("#{table_name}.#{column} = ?", param)
+      else
+        return resource.where("#{table_name}.#{column} = ?", param)
+      end
     end
   end
 
@@ -25,7 +33,11 @@ module ActiveHashRelation::ColumnFilters
   def filter_string(resource, column, table_name, param)
     if param.is_a? Array
       n_param = param.to_s.gsub("\"","'").gsub("[","").gsub("]","") #fix this!
-      return resource.where("#{table_name}.#{column} IN (#{n_param})")
+      if @is_not
+        return resource.where.not("#{table_name}.#{column} IN (#{n_param})")
+      else
+        return resource.where("#{table_name}.#{column} IN (#{n_param})")
+      end
     elsif param.is_a? Hash
       if !param[:null].nil?
         return null_filters(resource, table_name, column, param)
@@ -33,7 +45,11 @@ module ActiveHashRelation::ColumnFilters
         return apply_like_filters(resource, table_name, column, param)
       end
     else
-      return resource.where("#{table_name}.#{column} = ?", param)
+      if @is_not
+        return resource.where.not("#{table_name}.#{column} = ?", param)
+      else
+        return resource.where("#{table_name}.#{column} = ?", param)
+      end
     end
   end
 
@@ -44,7 +60,11 @@ module ActiveHashRelation::ColumnFilters
   def filter_date(resource, column, table_name, param)
     if param.is_a? Array
       n_param = param.to_s.gsub("\"","'").gsub("[","").gsub("]","") #fix this!
-      return resource.where("#{table_name}.#{column} IN (#{n_param})")
+      if @is_not
+        return resource.where.not("#{table_name}.#{column} IN (#{n_param})")
+      else
+        return resource.where("#{table_name}.#{column} IN (#{n_param})")
+      end
     elsif param.is_a? Hash
       if !param[:null].nil?
         return null_filters(resource, table_name, column, param)
@@ -52,7 +72,11 @@ module ActiveHashRelation::ColumnFilters
         return apply_leq_geq_le_ge_filters(resource, table_name, column, param)
       end
     else
-      resource = resource.where(column => param)
+      if @is_not
+        resource = resource.where.not(column => param)
+      else
+        resource = resource.where(column => param)
+      end
     end
 
     return resource
@@ -61,7 +85,11 @@ module ActiveHashRelation::ColumnFilters
   def filter_datetime(resource, column, table_name, param)
     if param.is_a? Array
       n_param = param.to_s.gsub("\"","'").gsub("[","").gsub("]","") #fix this!
-      return resource = resource.where("#{table_name}.#{column} IN (#{n_param})")
+      if @is_not
+        return resource = resource.where.not("#{table_name}.#{column} IN (#{n_param})")
+      else
+        return resource = resource.where("#{table_name}.#{column} IN (#{n_param})")
+      end
     elsif param.is_a? Hash
       if !param[:null].nil?
         return null_filters(resource, table_name, column, param)
@@ -69,7 +97,11 @@ module ActiveHashRelation::ColumnFilters
         return apply_leq_geq_le_ge_filters(resource, table_name, column, param)
       end
     else
-      resource = resource.where(column => param)
+      if @is_not
+        resource = resource.where.not(column => param)
+      else
+        resource = resource.where(column => param)
+      end
     end
 
     return resource
@@ -85,7 +117,11 @@ module ActiveHashRelation::ColumnFilters
         b_param = ActiveRecord::Type::Boolean.new.type_cast_from_database(param)
       end
 
-      resource = resource.where(column => b_param)
+      if @is_not
+        resource = resource.where.not(column => b_param)
+      else
+        resource = resource.where(column => b_param)
+      end
     end
   end
 
@@ -95,15 +131,31 @@ module ActiveHashRelation::ColumnFilters
     return resource.where("#{table_name}.#{column} = ?", param[:eq]) if param[:eq]
 
     if !param[:leq].blank?
-      resource = resource.where("#{table_name}.#{column} <= ?", param[:leq])
+      if @is_not
+        resource = resource.where.not("#{table_name}.#{column} <= ?", param[:leq])
+      else
+        resource = resource.where("#{table_name}.#{column} <= ?", param[:leq])
+      end
     elsif !param[:le].blank?
-      resource = resource.where("#{table_name}.#{column} < ?", param[:le])
+      if @is_not
+        resource = resource.where.not("#{table_name}.#{column} < ?", param[:le])
+      else
+        resource = resource.where("#{table_name}.#{column} < ?", param[:le])
+      end
     end
 
     if !param[:geq].blank?
-      resource = resource.where("#{table_name}.#{column} >= ?", param[:geq])
+      if @is_not
+        resource = resource.where.not("#{table_name}.#{column} >= ?", param[:geq])
+      else
+        resource = resource.where("#{table_name}.#{column} >= ?", param[:geq])
+      end
     elsif !param[:ge].blank?
-      resource = resource.where("#{table_name}.#{column} > ?", param[:ge])
+      if @is_not
+        resource = resource.where.not("#{table_name}.#{column} > ?", param[:ge])
+      else
+        resource = resource.where("#{table_name}.#{column} > ?", param[:ge])
+      end
     end
 
     return resource
@@ -114,19 +166,35 @@ module ActiveHashRelation::ColumnFilters
     like_method = "ILIKE" if param[:with_ilike]
 
     if !param[:starts_with].blank?
-      resource = resource.where("#{table_name}.#{column} #{like_method} ?", "#{param[:starts_with]}%")
+      if @is_not
+        resource = resource.where.not("#{table_name}.#{column} #{like_method} ?", "#{param[:starts_with]}%")
+      else
+        resource = resource.where("#{table_name}.#{column} #{like_method} ?", "#{param[:starts_with]}%")
+      end
     end
 
     if !param[:ends_with].blank?
-      resource = resource.where("#{table_name}.#{column} #{like_method} ?", "%#{param[:ends_with]}")
+      if @is_not
+        resource = resource.where.not("#{table_name}.#{column} #{like_method} ?", "%#{param[:ends_with]}")
+      else
+        resource = resource.where("#{table_name}.#{column} #{like_method} ?", "%#{param[:ends_with]}")
+      end
     end
 
     if !param[:like].blank?
-      resource = resource.where("#{table_name}.#{column} #{like_method} ?", "%#{param[:like]}%")
+      if @is_not
+        resource = resource.where.not("#{table_name}.#{column} #{like_method} ?", "%#{param[:like]}%")
+      else
+        resource = resource.where("#{table_name}.#{column} #{like_method} ?", "%#{param[:like]}%")
+      end
     end
 
     if !param[:eq].blank?
-      resource = resource.where("#{table_name}.#{column} = ?", param[:eq])
+      if @is_not
+        resource = resource.where.not("#{table_name}.#{column} = ?", param[:eq])
+      else
+        resource = resource.where("#{table_name}.#{column} = ?", param[:eq])
+      end
     end
 
     return resource
@@ -134,11 +202,19 @@ module ActiveHashRelation::ColumnFilters
   
   def null_filters(resource, table_name, column, param)
     if param[:null] == true
-      resource = resource.where("#{table_name}.#{column} IS NULL")
+      if @is_not
+        resource = resource.where.not("#{table_name}.#{column} IS NULL")
+      else
+        resource = resource.where("#{table_name}.#{column} IS NULL")
+      end
     end
     
     if param[:null] == false
-      resource = resource.where("#{table_name}.#{column} IS NOT NULL")
+      if @is_not
+        resource = resource.where.not("#{table_name}.#{column} IS NOT NULL")
+      else
+        resource = resource.where("#{table_name}.#{column} IS NOT NULL")
+      end
     end
     
     return resource

data/lib/active_hash_relation/filter_applier.rb

@@ -9,7 +9,7 @@ module ActiveHashRelation
 
     attr_reader :configuration
 
-    def initialize(resource, params, include_associations: false, model: nil)
+    def initialize(resource, params, include_associations: false, model: nil, is_not: false)
       @configuration = Module.nesting.last.configuration
       @resource = resource
       if params.respond_to?(:to_unsafe_h)
@@ -19,10 +19,12 @@ module ActiveHashRelation
       end
       @include_associations = include_associations
       @model = find_model(model)
+      is_not ? @is_not = true : @is_not = false
     end
 
     def apply_filters
       run_or_filters
+      run_not_filters
 
       table_name = @model.table_name
       @model.columns.each do |c|
@@ -68,7 +70,7 @@ module ActiveHashRelation
     def run_or_filters
       if @params[:or].is_a?(Array)
         if ActiveRecord::VERSION::MAJOR < 5
-          return Rails.logger.warn("OR query is supported on ActiveRecord 5+") 
+          return Rails.logger.warn("OR query is supported on ActiveRecord 5+")
         end
 
         if @params[:or].length >= 2
@@ -83,5 +85,16 @@ module ActiveHashRelation
         end
       end
     end
+
+    def run_not_filters
+      if @params[:not].is_a?(Hash) && !@params[:not].blank?
+        @resource = self.class.new(
+          @resource,
+          @params[:not],
+          include_associations: @include_associations,
+          is_not: true
+        ).apply_filters
+      end
+    end
   end
 end

data/lib/active_hash_relation/sort_filters.rb

@@ -12,8 +12,16 @@ module ActiveHashRelation::SortFilters
   end
 
   def apply_hash_sort(resource, params, model = nil)
-    if model.columns.map(&:name).include?(params[:property].to_s)
-      resource = resource.order(params[:property] => (params[:order] || :desc) )
+    if not params[:property].blank?
+      if model.columns.map(&:name).include?(params[:property].to_s)
+        resource = resource.order(params[:property] => (params[:order] || :desc) )
+      end
+    else
+      params.each do |property, order|
+        if model.columns.map(&:name).include?(property.to_s)
+          resource = resource.order(property => (order || :desc) )
+        end
+      end
     end
 
     return resource

data/lib/active_hash_relation/version.rb

@@ -1,3 +1,3 @@
 module ActiveHashRelation
-  VERSION = "1.2.0"
+  VERSION = "1.4.0"
 end

data/spec/tests/not_filter_spec.rb

@@ -0,0 +1,105 @@
+describe ActiveHashRelation do
+  include Helpers
+
+  context 'NOT filter' do
+    it "one NOT clause" do
+      hash = {not: {name: 'Filippos'}}
+
+      query = HelperClass.new.apply_filters(User.all, hash).to_sql
+      expected_query = q(
+        "SELECT users.* FROM users WHERE (NOT (users.name = 'Filippos'))"
+      )
+
+      expect(strip(query)).to eq expected_query.to_s
+    end
+
+    it "multiple NOT clauses" do
+      hash = {not: {name: 'Filippos', email: 'vasilakisfil@gmail.com'}}
+
+      query = HelperClass.new.apply_filters(User.all, hash).to_sql
+      expected_query = q(
+        "SELECT users.* FROM users WHERE",
+        "(NOT (users.name = 'Filippos'))",
+        "AND",
+        "(NOT (users.email = 'vasilakisfil@gmail.com'))"
+      )
+
+      expect(strip(query)).to eq expected_query.to_s
+    end
+
+    if ActiveRecord::VERSION::MAJOR >= 5
+      it "NOT clause inside OR clause" do
+        hash = {or: [{not: {name: 'Filippos', token: '123'}}, {not: {name: 'Vasilis'}}]}
+
+        query = HelperClass.new.apply_filters(User.all, hash).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "WHERE",
+          "(",
+            "(NOT (users.name = 'Filippos')) AND (NOT (users.token = '123'))",
+            "OR",
+            "(NOT (users.name = 'Vasilis'))",
+          ")"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+    end
+
+    it "complex NOT clause" do
+      hash = {not: {name: 'Filippos', email: {ends_with: '@gmail.com'}}}
+
+      query = HelperClass.new.apply_filters(User.all, hash).to_sql
+      expected_query = q(
+        "SELECT users.* FROM users",
+        "WHERE",
+        "(NOT (users.name = 'Filippos'))",
+        "AND",
+        "(NOT (users.email LIKE '%@gmail.com'))",
+      )
+
+      expect(strip(query)).to eq expected_query.to_s
+    end
+
+    context "on NULL" do
+      it "NOT clause on null" do
+        hash = {not: {name: {null: true}}}
+
+        query = HelperClass.new.apply_filters(User.all, hash).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users WHERE (NOT (users.name IS NULL))"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+
+      it "NOT clause on not null" do
+        hash = {not: {name: {null: false}}}
+
+        query = HelperClass.new.apply_filters(User.all, hash).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users WHERE (NOT (users.name IS NOT NULL))"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+      end
+    end
+
+    it "NOT clause on associations" do
+        hash = {microposts: {not: {content: 'Sveavägen 4', id: 1}}}
+
+        query = HelperClass.new.apply_filters(User.all, hash, include_associations: true).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "INNER JOIN microposts ON microposts.user_id = users.id",
+          "WHERE",
+          "(NOT (microposts.id = 1))",
+          "AND",
+          "(NOT (microposts.content = 'Sveavägen 4'))"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+    end
+
+  end
+end

data/spec/tests/sorting_spec.rb

@@ -2,11 +2,12 @@ describe ActiveHashRelation do
   include Helpers
 
   context 'sorting' do
+
     context "one where clause" do
       it "asc" do
         hash = {
           microposts_count: 10,
-          sort: {property: :microposts_count, order: :asc}
+          sort: {microposts_count: :asc}
         }
 
         query = HelperClass.new.apply_filters(User.all, hash).to_sql
@@ -19,10 +20,10 @@ describe ActiveHashRelation do
         expect(strip(query)).to eq expected_query.to_s
       end
 
-      it "multiple where clause" do
+      it "desc" do
           hash = {
             microposts_count: 10,
-            sort: {property: :microposts_count, order: :desc}
+            sort: {microposts_count: :desc}
           }
 
           query = HelperClass.new.apply_filters(User.all, hash).to_sql
@@ -41,7 +42,7 @@ describe ActiveHashRelation do
         hash = {
           followers_count: {leq: 20},
           microposts_count: 10,
-          sort: {property: :microposts_count, order: :asc}
+          sort: {microposts_count: :asc}
         }
 
         query = HelperClass.new.apply_filters(User.all, hash).to_sql
@@ -55,11 +56,11 @@ describe ActiveHashRelation do
         expect(strip(query)).to eq expected_query.to_s
       end
 
-      it "multiple where clause" do
+      it "desc" do
         hash = {
         followers_count: {leq: 20},
           microposts_count: 10,
-          sort: {property: :microposts_count, order: :desc}
+          sort: {microposts_count: :desc}
         }
 
         query = HelperClass.new.apply_filters(User.all, hash).to_sql
@@ -75,26 +76,235 @@ describe ActiveHashRelation do
     end
 
     context "multiple sorting properties" do
-      it "with single where clause" do
+      context "as a hashe" do
+        it "with single where clause" do
+          hash = {
+            microposts_count: 10,
+            sort: {
+              microposts_count: :asc,
+              followings_count: :desc
+            }
+          }
+
+          query = HelperClass.new.apply_filters(User.all, hash).to_sql
+          expected_query = q(
+            "SELECT users.* FROM users",
+            "WHERE (users.microposts_count = 10)",
+            "ORDER BY users.microposts_count ASC, users.followings_count DESC"
+          )
+
+          expect(strip(query)).to eq expected_query.to_s
+        end
+
+        it "when the sorting column does not exist" do
+          hash = {
+            microposts_count: 10,
+            sort: {
+              i_do_not_exist: :asc,
+              followings_count: :desc
+            }
+          }
+
+          query = HelperClass.new.apply_filters(User.all, hash).to_sql
+          expected_query = q(
+            "SELECT users.* FROM users",
+            "WHERE (users.microposts_count = 10)",
+            "ORDER BY users.followings_count DESC"
+          )
+
+          expect(strip(query)).to eq expected_query.to_s
+        end
+      end
+
+      context "as an array of hashes (not recommended)" do
+        it "with single where clause" do
+          hash = {
+            microposts_count: 10,
+            sort: [{
+              microposts_count: :asc,
+            }, {
+              followings_count: :desc
+            }]
+          }
+
+          query = HelperClass.new.apply_filters(User.all, hash).to_sql
+          expected_query = q(
+            "SELECT users.* FROM users",
+            "WHERE (users.microposts_count = 10)",
+            "ORDER BY users.microposts_count ASC, users.followings_count DESC"
+          )
+
+          expect(strip(query)).to eq expected_query.to_s
+        end
+
+        it "when the sorting column does not exist" do
+          hash = {
+            microposts_count: 10,
+            sort: [{
+              i_do_not_exist: :asc,
+            }, {
+              followings_count: :desc
+            }]
+          }
+
+          query = HelperClass.new.apply_filters(User.all, hash).to_sql
+          expected_query = q(
+            "SELECT users.* FROM users",
+            "WHERE (users.microposts_count = 10)",
+            "ORDER BY users.followings_count DESC"
+          )
+
+          expect(strip(query)).to eq expected_query.to_s
+        end
+      end
+
+      it "when the sorting column does not exist" do
         hash = {
           microposts_count: 10,
-          sort: [{
-            property: :microposts_count, order: :asc,
-          }, {
-            property: :followings_count, order: :desc
-          }]
+          sort: {i_do_not_exist: :asc}
         }
 
         query = HelperClass.new.apply_filters(User.all, hash).to_sql
         expected_query = q(
           "SELECT users.* FROM users",
-          "WHERE (users.microposts_count = 10)",
-          "ORDER BY users.microposts_count ASC, users.followings_count DESC"
+          "WHERE (users.microposts_count = 10)"
         )
 
         expect(strip(query)).to eq expected_query.to_s
+
       end
     end
-  end
 
+    context "deprecated API" do
+      context "one where clause" do
+        it "asc" do
+          hash = {
+            microposts_count: 10,
+            sort: {property: :microposts_count, order: :asc}
+          }
+
+          query = HelperClass.new.apply_filters(User.all, hash).to_sql
+          expected_query = q(
+            "SELECT users.* FROM users",
+            "WHERE (users.microposts_count = 10)",
+            "ORDER BY users.microposts_count ASC"
+          )
+
+          expect(strip(query)).to eq expected_query.to_s
+        end
+
+        it "desc" do
+            hash = {
+              microposts_count: 10,
+              sort: {property: :microposts_count, order: :desc}
+            }
+
+            query = HelperClass.new.apply_filters(User.all, hash).to_sql
+            expected_query = q(
+              "SELECT users.* FROM users",
+              "WHERE (users.microposts_count = 10)",
+              "ORDER BY users.microposts_count DESC"
+            )
+
+            expect(strip(query)).to eq expected_query.to_s
+        end
+      end
+
+      context "multiple where clauses" do
+        it "asc" do
+          hash = {
+            followers_count: {leq: 20},
+            microposts_count: 10,
+            sort: {property: :microposts_count, order: :asc}
+          }
+
+          query = HelperClass.new.apply_filters(User.all, hash).to_sql
+          expected_query = q(
+            "SELECT users.* FROM users",
+            "WHERE (users.microposts_count = 10)",
+            "AND (users.followers_count <= 20)",
+            "ORDER BY users.microposts_count ASC"
+          )
+
+          expect(strip(query)).to eq expected_query.to_s
+        end
+
+        it "desc" do
+          hash = {
+          followers_count: {leq: 20},
+            microposts_count: 10,
+            sort: {property: :microposts_count, order: :desc}
+          }
+
+          query = HelperClass.new.apply_filters(User.all, hash).to_sql
+          expected_query = q(
+            "SELECT users.* FROM users",
+            "WHERE (users.microposts_count = 10)",
+            "AND (users.followers_count <= 20)",
+            "ORDER BY users.microposts_count DESC"
+          )
+
+          expect(strip(query)).to eq expected_query.to_s
+        end
+      end
+
+      context "multiple sorting properties" do
+        it "with single where clause" do
+          hash = {
+            microposts_count: 10,
+            sort: [{
+              property: :microposts_count, order: :asc,
+            }, {
+              property: :followings_count, order: :desc
+            }]
+          }
+
+          query = HelperClass.new.apply_filters(User.all, hash).to_sql
+          expected_query = q(
+            "SELECT users.* FROM users",
+            "WHERE (users.microposts_count = 10)",
+            "ORDER BY users.microposts_count ASC, users.followings_count DESC"
+          )
+
+          expect(strip(query)).to eq expected_query.to_s
+        end
+
+      it "when the sorting column does not exist" do
+          hash = {
+            microposts_count: 10,
+            sort: [{
+              property: :i_do_not_exist, order: :asc,
+            }, {
+              property: :followings_count, order: :desc
+            }]
+          }
+
+          query = HelperClass.new.apply_filters(User.all, hash).to_sql
+          expected_query = q(
+            "SELECT users.* FROM users",
+            "WHERE (users.microposts_count = 10)",
+            "ORDER BY users.followings_count DESC"
+          )
+
+          expect(strip(query)).to eq expected_query.to_s
+        end
+      end
+
+      it "when the sorting column does not exist" do
+        hash = {
+          microposts_count: 10,
+          sort: {property: :i_do_not_exist, order: :asc}
+        }
+
+        query = HelperClass.new.apply_filters(User.all, hash).to_sql
+        expected_query = q(
+          "SELECT users.* FROM users",
+          "WHERE (users.microposts_count = 10)"
+        )
+
+        expect(strip(query)).to eq expected_query.to_s
+
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_hash_relation
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Filippos Vasilakis
@@ -331,6 +331,7 @@ files:
 - spec/tests/associations/has_one_spec.rb
 - spec/tests/booleans_spec.rb
 - spec/tests/limit_spec.rb
+- spec/tests/not_filter_spec.rb
 - spec/tests/null_spec.rb
 - spec/tests/numbers_spec.rb
 - spec/tests/or_filter_spec.rb
@@ -472,6 +473,7 @@ test_files:
 - spec/tests/associations/has_one_spec.rb
 - spec/tests/booleans_spec.rb
 - spec/tests/limit_spec.rb
+- spec/tests/not_filter_spec.rb
 - spec/tests/null_spec.rb
 - spec/tests/numbers_spec.rb
 - spec/tests/or_filter_spec.rb