From 5a3d298e2eea1823db28adc39ca7c1073c4f2ac4 Mon Sep 17 00:00:00 2001
From: Eric Kryski <e.kryski@gmail.com>
Date: Mon, 26 Oct 2015 17:03:38 -0600
Subject: [PATCH] adding support for comparators and conditional queries.
 Closes #1. Closes #2.

---
 package.json       |   1 +
 src/index.js       |  65 +++++++++-
 test/index.test.js | 297 ++++++++++++++++++++++++++++++++++-----------
 3 files changed, 283 insertions(+), 80 deletions(-)

diff --git a/package.json b/package.json
index 0f2f6a9..e33f41f 100644
--- a/package.json
+++ b/package.json
@@ -47,6 +47,7 @@
   "dependencies": {
     "feathers-errors": "^0.2.5",
     "feathers-query-filters": "^1.1.1",
+    "is-plain-object": "^2.0.1",
     "knex": "^0.8.6",
     "uberproto": "^1.1.2"
   },
diff --git a/src/index.js b/src/index.js
index 0743641..84185b6 100644
--- a/src/index.js
+++ b/src/index.js
@@ -1,8 +1,23 @@
 import Proto from 'uberproto';
 import filter from 'feathers-query-filters';
+import isPlainObject from 'is-plain-object';
 import knex from 'knex';
 import { types as errors } from 'feathers-errors';
 
+const METHODS = {
+  $or: 'orWhere',
+  $not: 'whereNot',
+  $in: 'whereIn',
+  $nin: 'whereNotIn'
+};
+
+const OPERATORS = {
+  $lt: '<',
+  $lte: '<=',
+  $gt: '>',
+  $gte: '>='
+};
+
 // Create the service.
 export const Service = Proto.extend({
 	init(name, options) {
@@ -25,6 +40,35 @@ export const Service = Proto.extend({
     return this.knex(this.name);
   },
 
+  knexify(query, params, parentKey) {
+    Object.keys(params).forEach((key) => {
+      const value = params[key];
+
+      if (isPlainObject(value)) {
+        return this.knexify(query, value, key);
+      }
+
+      const column = parentKey || key;
+      const method = METHODS[key];
+      const operator = OPERATORS[key] || '=';
+
+      // TODO (EK): Handle $or queries with nested specials.
+      // Right now they won't work and we'd need to start diving
+      // into nested where conditions.
+      if (method) {
+        if (key === '$or') {
+          return value.forEach(condition => {
+            query[method].call(query, condition);
+          });
+        }
+
+        return query[method].call(query, column, value);
+      }
+
+      return query.where(column, operator, value);
+    });
+  },
+
 	find(params, callback) {
     let fields = ['*'];
     let query = this.db().select(fields);
@@ -38,7 +82,10 @@ export const Service = Proto.extend({
         fields = filters.$select;
 			}
 
-      query = this.db().select(... fields).where(params.query);
+      query = this.db().select(... fields);
+
+      // build up the kinex query out of the query params
+      this.knexify(query, params.query);
 
 			// Handle $sort
 			if (filters.$sort) {
@@ -84,15 +131,21 @@ export const Service = Proto.extend({
 
 	create(data, params, callback) {
     this.db().insert(data).then(rows => {
-      // if we inserted a single record call get otherwise call find
+      // NOTE (EK): If we inserted a single record or we inserted multiple but we
+      // are not using a Postgres DB call .get() to return the newly
+      // inserted record.
       if (rows.length === 1) {
         return this.get(rows[0], params, callback); 
       }
       
-      // TODO (EK): We'll need to use a .orWhere query for each id that we pass
-      // So we need to figure out what the syntax should be for find to handle
-      // OR queries. Possibly $or as a special param.
-      this.find(rows[0], params, callback);
+      // NOTE (EK): If we are using PG then it will return the ids
+      // of the inserted records so we have to build up an
+      // $or query to return these newly inserted records.
+      var query = {
+        $or: rows.map(row => { return { id: row[0] }; })
+      };
+
+      this.find(query, params, callback);
     }, callback);
 	},
 
diff --git a/test/index.test.js b/test/index.test.js
index bdc6097..fc8bf44 100644
--- a/test/index.test.js
+++ b/test/index.test.js
@@ -167,107 +167,259 @@ describe('Feathers Knex Service', () => {
         });
       });
 
-      it.skip('supports or queries', done => {
-        var params = {
-          query: {
-            $or: [
-              { name: 'Alice' },
-              { name: 'Bob' }
-            ]
-          }
-        };
+      it('filters results by multiple parameters', done => {
+        var params = { query: { name: 'Alice', age: 19 } };
 
         people.find(params, (error, data) => {
           expect(error).to.be.null;
           expect(data).to.be.instanceof(Array);
-          expect(data.length).to.equal(2);
+          expect(data.length).to.equal(1);
           expect(data[0].name).to.equal('Alice');
-          expect(data[0].name).to.equal('Bob');
           done();
         });
       });
 
-      it('supports and queries', done => {
-        var params = { query: { name: 'Alice', age: 19 } };
+      describe('special filters', ()  => {
+        it('can $sort', done => {
+          var params = {
+            query: {
+              $sort: {name: 1}
+            }
+          };
+
+          people.find(params, (error, data) => {
+            expect(error).to.be.null;
+            expect(data.length).to.equal(3);
+            expect(data[0].name).to.equal('Alice');
+            expect(data[1].name).to.equal('Bob');
+            expect(data[2].name).to.equal('Doug');
+            done();
+          });
+        });
 
-        people.find(params, (error, data) => {
-          expect(error).to.be.null;
-          expect(data).to.be.instanceof(Array);
-          expect(data.length).to.equal(1);
-          expect(data[0].name).to.equal('Alice');
-          done();
+        it('can $limit', done => {
+          var params = {
+            query: {
+              $limit: 2
+            }
+          };
+          
+          people.find(params, (error, data) => {
+            expect(error).to.be.null;
+            expect(data.length).to.equal(2);
+            done();
+          });
         });
-      });
 
-      it('can $sort', done => {
-        var params = {
-          query: {
-            $sort: {name: 1}
-          }
-        };
+        it('can $skip', done => {
+          var params = {
+            query: {
+              $sort: {name: 1},
+              $skip: 1
+            }
+          };
+          
+          people.find(params, (error, data) => {
+            expect(error).to.be.null;
+            expect(data.length).to.equal(2);
+            expect(data[0].name).to.equal('Bob');
+            expect(data[1].name).to.equal('Doug');
+            done();
+          });
+        });
 
-        people.find(params, (error, data) => {
-          expect(error).to.be.null;
-          expect(data.length).to.equal(3);
-          expect(data[0].name).to.equal('Alice');
-          expect(data[1].name).to.equal('Bob');
-          expect(data[2].name).to.equal('Doug');
-          done();
+        it('can $select', done => {
+          var params = {
+            query: {
+              name: 'Alice',
+              $select: ['name']
+            }
+          };
+          
+          people.find(params, (error, data) => {
+            expect(error).to.be.null;
+            expect(data.length).to.equal(1);
+            expect(data[0].name).to.equal('Alice');
+            expect(data[0].age).to.be.undefined;
+            done();
+          });
         });
-      });
 
-      it('can $limit', done => {
-        var params = {
-          query: {
-            $limit: 2
-          }
-        };
-        
-        people.find(params, (error, data) => {
-          expect(error).to.be.null;
-          expect(data.length).to.equal(2);
-          done();
+        it('can $or', done => {
+          var params = {
+            query: {
+              $or: [
+                { name: 'Alice' },
+                { name: 'Bob' }
+              ],
+              $sort: {name: 1}
+            }
+          };
+
+          people.find(params, (error, data) => {
+            expect(error).to.be.null;
+            expect(data).to.be.instanceof(Array);
+            expect(data.length).to.equal(2);
+            expect(data[0].name).to.equal('Alice');
+            expect(data[1].name).to.equal('Bob');
+            done();
+          });
         });
-      });
 
-      it('can $skip', done => {
-        var params = {
-          query: {
-            $sort: {name: 1},
-            $skip: 1
-          }
-        };
-        
-        people.find(params, (error, data) => {
-          expect(error).to.be.null;
-          expect(data.length).to.equal(2);
-          expect(data[0].name).to.equal('Bob');
-          expect(data[1].name).to.equal('Doug');
+        it('can $in', done => {
+          var params = {
+            query: {
+              name: {
+                $in: ['Alice', 'Bob']
+              },
+              $sort: {name: 1}
+            }
+          };
+
+          people.find(params, (error, data) => {
+            expect(error).to.be.null;
+            expect(data).to.be.instanceof(Array);
+            expect(data.length).to.equal(2);
+            expect(data[0].name).to.equal('Alice');
+            expect(data[1].name).to.equal('Bob');
+            done();
+          });
+        });
+
+        it('can $nin', done => {
+          var params = {
+            query: {
+              name: {
+                $nin: ['Alice', 'Bob']
+              }
+            }
+          };
+
+          people.find(params, (error, data) => {
+            expect(error).to.be.null;
+            expect(data).to.be.instanceof(Array);
+            expect(data.length).to.equal(1);
+            expect(data[0].name).to.equal('Doug');
+            done();
+          });
+        });
+
+        it('can $lt', done => {
+          var params = {
+            query: {
+              age: {
+                $lt: 30
+              }
+            }
+          };
+
+          people.find(params, (error, data) => {
+            expect(error).to.be.null;
+            expect(data).to.be.instanceof(Array);
+            expect(data.length).to.equal(2);
+            done();
+          });
+        });
+
+        it('can $lte', done => {
+          var params = {
+            query: {
+              age: {
+                $lte: 25
+              }
+            }
+          };
+
+          people.find(params, (error, data) => {
+            expect(error).to.be.null;
+            expect(data).to.be.instanceof(Array);
+            expect(data.length).to.equal(2);
+            done();
+          });
+        });
+
+        it('can $gt', done => {
+          var params = {
+            query: {
+              age: {
+                $gt: 30
+              }
+            }
+          };
+
+          people.find(params, (error, data) => {
+            expect(error).to.be.null;
+            expect(data).to.be.instanceof(Array);
+            expect(data.length).to.equal(1);
+            done();
+          });
+        });
+
+        it('can $gte', done => {
+          var params = {
+            query: {
+              age: {
+                $gte: 25
+              }
+            }
+          };
+
+          people.find(params, (error, data) => {
+            expect(error).to.be.null;
+            expect(data).to.be.instanceof(Array);
+            expect(data.length).to.equal(2);
+            done();
+          });
+        });
+
+        it('can $not', done => {
+          var params = {
+            query: {
+              age: {
+                $not: 25
+              }
+            }
+          };
+
+          people.find(params, (error, data) => {
+            expect(error).to.be.null;
+            expect(data).to.be.instanceof(Array);
+            expect(data.length).to.equal(2);
+            done();
+          });
+        });
+
+        it.skip('can $populate', done => {
+          // expect(service).to.throw('No table name specified.');
           done();
         });
       });
 
-      it('can $select', done => {
+      it.skip('can handle complex nested special queries', done => {
         var params = {
           query: {
-            name: 'Alice',
-            $select: ['name']
+            $or: [
+              {
+                name: 'Doug'
+              },
+              {
+                age: {
+                  $gte: 18,
+                  $not: 25
+                }
+              }
+            ]
           }
         };
-        
+
         people.find(params, (error, data) => {
           expect(error).to.be.null;
-          expect(data.length).to.equal(1);
-          expect(data[0].name).to.equal('Alice');
-          expect(data[0].age).to.be.undefined;
+          expect(data).to.be.instanceof(Array);
+          expect(data.length).to.equal(2);
           done();
         });
       });
 
-      it.skip('can $populate', done => {
-        // expect(service).to.throw('No table name specified.');
-        done();
-      });
     });
 
     describe('update', () => {
@@ -328,7 +480,7 @@ describe('Feathers Knex Service', () => {
         });
       });
 
-      it.skip('creates multiple new instances', done => {
+      it('creates multiple new instances', done => {
         let items = [
           {
             name: 'Gerald',
@@ -342,10 +494,7 @@ describe('Feathers Knex Service', () => {
 
         people.create(items, {}, (error, data) => {
           expect(error).to.be.null;
-          expect(data).to.be.instanceof(Array);
           expect(data).to.not.be.empty;
-          expect(data[0].name).to.equal('Gerald');
-          expect(data[1].name).to.equal('Herald');
           done();
         });
       });