multiple within the same object works

Author: justinbmeyer

src/serializers/basic-query-test.js

@@ -175,6 +175,40 @@ testHelpers.dev.devOnlyTest("warn if query properties are not defined (#8)", fun
     QUnit.equal(finishErrorCheck(), 1);
 });
 
+QUnit.test("gt and lt", function(){
+    var query = {
+        filter: {
+            age: {
+                $gt: 0,
+                $lt: 100
+            }
+        }
+    };
+
+    var converter = makeBasicQueryConvert(EmptySchema);
+
+    var basicQuery = converter.hydrate(query);
+
+    QUnit.deepEqual(basicQuery.filter, new logicTypes.KeysAnd({
+        age: new is.And([
+            new is.GreaterThan(0),
+            new is.LessThan(100)
+        ])
+    }));
+
+    var res = converter.serializer.serialize(basicQuery);
+
+    QUnit.deepEqual(res, {
+        filter: {
+            age: {
+                $gt: 0,
+                $lt: 100
+            }
+        }
+    });
+
+});
+
 /*
 QUnit.skip("nested properties within ors", function(){
     var query = {

src/serializers/comparisons.js

@@ -1,5 +1,6 @@
 var is = require("../types/comparisons");
 var Serializer = require("../serializer");
+var canReflect = require("can-reflect");
 
 function makeNew(Constructor) {
     return function(value){
@@ -45,7 +46,7 @@ addHydrateFrom("$gt", makeNew(is.GreaterThan));
 addHydrateFrom("$gte", makeNew(is.GreaterThanEqual));
 addHydrateFromValues("$in", makeNew(is.In));
 addHydrateFrom("$lt", makeNew(is.LessThan));
-addHydrateFrom("$lt", makeNew(is.LessThanEqual));
+addHydrateFrom("$lte", makeNew(is.LessThanEqual));
 addHydrateFromValues("$nin", makeNew(is.GreaterThan));
 
 
@@ -66,6 +67,13 @@ var serializer = new Serializer([
     [is.GreaterThanEqual, function(gte, serialize){ return {$gte: serialize(gte.value) }; }],
     [is.LessThan, function(lt, serialize){ return {$lt: serialize(lt.value) }; }],
     [is.LessThanEqual, function(lt, serialize){ return {$lte: serialize(lt.value) }; }],
+    [is.And, function(and, serialize){
+        var obj = {};
+        and.values.forEach(function(clause){
+            canReflect.assignMap(obj, serialize(clause) );
+        });
+        return obj;
+    }]
     /*[is.Or, function(or, serialize){
         return {
             $or: or.values.map(function(value){
@@ -87,13 +95,20 @@ module.exports = {
         }
         else if(value && typeof value === "object") {
             var keys = Object.keys(value);
-            if(keys.length === 1) {
-                var first = keys[0];
-                var hydrator = hydrateMap[first];
-                if(!hydrator) {
-                    return hydrateUnknown(value);
+            var allKeysAreComparisons = keys.every(function(key){
+                return hydrateMap[key]
+            })
+            if(allKeysAreComparisons) {
+                var andClauses = keys.map(function(key){
+                    var part = {};
+                    part[key] = value[key];
+                    var hydrator = hydrateMap[key];
+                    return hydrator(part, hydrateUnknown);
+                });
+                if(andClauses.length > 1) {
+                    return new is.And(andClauses);
                 } else {
-                    return hydrator(value, hydrateUnknown);
+                    return andClauses[0];
                 }
             } else {
                 return hydrateUnknown(value);