jedlik 1.0.7 → 1.0.10

package/index.js

@@ -1,9 +1,10 @@
-function Jedlik() {
+function Jedlik(booleanSupport) {
   this._data = {
     attributes: {},
     items: [],
     localSecondaryIndexes: [],
-    expected: []
+    expected: [],
+    booleanSupport: booleanSupport
   };
   this.addIfExists = function(attributeName, fieldName, json) {
     if (this._data[fieldName]) {
@@ -97,7 +98,7 @@ Jedlik.prototype.update = function() {
     json.Key[this._data.rangekey.key][this._data.rangekey.type] = this._data.rangekey.value;
   }
 
-  if (this._data.expected.length > 0){
+  if (this._data.expected.length > 0) {
     json.Expected = {};
   }
 
@@ -146,43 +147,81 @@ Jedlik.prototype.tablename = function(tablename) {
   return this;
 };
 
-var getType = function(value, nullable) {
+Jedlik.prototype._getType = function(value, nullable, subType) {
+  var self = this;
+
   if (nullable && value == null) {
     return 'NULL';
   }
 
   if (Array.isArray(value)) {
-    return (value.length === 0 || typeof value[0] == 'object') ? 'L' : 'SS';
+    if (subType || value.length === 0) {
+      return 'L';
+    }
+
+    var strings = true;
+
+    value.forEach(function(item) {
+      var type = self._getType(item, true, true);
+
+      if (type != 'S') {
+        strings = false;
+      }
+    });
+
+    return strings ? 'SS' : 'L';
+  }
+
+  if (this._data.booleanSupport && typeof value == 'boolean') {
+    return "BOOL"
   }
 
   return (typeof value == 'object') ? 'M' : Number.isFinite(value) ? 'N' : 'S';
 };
 
-var getValue = function(value, nullable) {
+Jedlik.prototype._getValue = function(value, nullable) {
+  var self = this;
+
   if (nullable && value == null) {
     return true;
   }
 
+  if (self._data.booleanSupport && typeof value == 'boolean') {
+    return value;
+  }
+
   if (Array.isArray(value)) {
-    if (value.length === 0 || typeof value[0] == 'object') {
-      var result = [];
-      value.forEach(function(item) {
-        result.push({ M: getValue(item) });
-      });
-      return result;
-    } else {
-      return value;
+    if (value.length === 0) {
+      return [];
     }
+
+    var result = [];
+    var strings = true;
+
+    value.forEach(function(item) {
+      var type = self._getType(item, true, true);
+
+      if (type != 'S') {
+        strings = false;
+      }
+
+      var data = {};
+      data[type] = self._getValue(item, true);
+
+      result.push(data);
+    });
+
+    return strings ? value : result;
   }
 
   if (typeof value == 'object') {
-    var result = {},
-      itemKeys = Object.keys(value);
+    var result = {};
+    var itemKeys = Object.keys(value);
 
     itemKeys.forEach(function(key) {
       var item = value[key];
       result[key] = {};
-      result[key][getType(item)] = getValue(item);
+      result[key][self._getType(item)] = self._getValue(item);
     });
     return result;
   }
@@ -194,7 +233,7 @@ Jedlik.prototype.hashkey = function(key, value, type) {
   this._data.hashkey = {
     key: key,
     value: value,
-    type: type || getType(value)
+    type: type || this._getType(value)
   };
   return this;
 };
@@ -203,7 +242,7 @@ Jedlik.prototype.starthashkey = function(key, value, type) {
   this._data.starthashkey = {
     key: key,
     value: value,
-    type: type || getType(value)
+    type: type || this._getType(value)
   };
   return this;
 };
@@ -212,7 +251,7 @@ Jedlik.prototype.startrangekey = function(key, value, type) {
   this._data.startrangekey = {
     key: key,
     value: value,
-    type: type || getType(value)
+    type: type || this._getType(value)
   };
   return this;
 };
@@ -220,8 +259,8 @@ Jedlik.prototype.startrangekey = function(key, value, type) {
 Jedlik.prototype.rangekey = function(key, value, comparisonOp, type) {
   this._data.rangekey = {
     key: key,
-    value: value && getValue(value),
-    type: type || getType(value),
+    value: value && this._getValue(value),
+    type: type || this._getType(value),
     comparisonOp: comparisonOp || 'EQ'
   };
   return this;
@@ -246,9 +285,9 @@ Jedlik.prototype.localIndexName = function(indexName) {
 Jedlik.prototype.rangekeyBetween = function(key, valueFrom, valueTo) {
   this._data.rangekeyBetween = {
     key: key,
-    valueFrom: valueFrom && getValue(valueFrom),
-    valueTo: valueTo && getValue(valueTo),
-    type: getType(valueFrom)
+    valueFrom: valueFrom && this._getValue(valueFrom),
+    valueTo: valueTo && this._getValue(valueTo),
+    type: this._getType(valueFrom)
   };
   return this;
 };
@@ -291,10 +330,10 @@ Jedlik.prototype.attribute = function(key, value, action) {
   return this.nullableAttribute(key, value, action);
 }
 
-Jedlik.prototype.nullableAttribute = function(key, value, action) {
+Jedlik.prototype.nullableAttribute = function(key, value, action) { 
   this._data.attributes[key] = {
-    value: getValue(value, true),
-    type: getType(value, true),
+    value: this._getValue(value, true),
+    type: this._getType(value, true),
     action: action || 'PUT'
   };
   return this;
@@ -313,8 +352,10 @@ Jedlik.prototype.del = function() {
   json.Key[this._data.hashkey.key] = {};
   json.Key[this._data.hashkey.key][this._data.hashkey.type] = this._data.hashkey.value;
 
-  json.Key[this._data.rangekey.key] = {};
-  json.Key[this._data.rangekey.key][this._data.rangekey.type] = this._data.rangekey.value;
+  if (this._data.rangekey) {
+    json.Key[this._data.rangekey.key] = {};
+    json.Key[this._data.rangekey.key][this._data.rangekey.type] = this._data.rangekey.value;
+  }
 
   this.addIfExists('TableName', 'tablename', json);
 
@@ -374,9 +415,9 @@ Jedlik.prototype.createTable = function() {
       });
       json.LocalSecondaryIndexes.push({
         IndexName: localSecondaryIndex.indexName,
-        KeySchema:[
-          {AttributeName: this._data.hashkey.key, KeyType: 'HASH' },
-          {AttributeName: localSecondaryIndex.key, KeyType: 'RANGE' }
+        KeySchema: [
+          { AttributeName: this._data.hashkey.key, KeyType: 'HASH' },
+          { AttributeName: localSecondaryIndex.key, KeyType: 'RANGE' }
         ],
         Projection: {
           ProjectionType: localSecondaryIndex.projectionType
@@ -417,7 +458,7 @@ Jedlik.prototype.batchWrite = function() {
       if (key !== 'tablename') {
         var value = item[key];
         itemDDB.PutRequest.Item[key] = {};
-        itemDDB.PutRequest.Item[key][getType(value)] = value.toString();
+        itemDDB.PutRequest.Item[key][that._getType(value)] = value.toString();
       }
     });
 
@@ -430,8 +471,8 @@ Jedlik.prototype.batchWrite = function() {
 Jedlik.prototype.expected = function (key, value, comparisonOp) {
   this._data.expected.push({
     key: key,
-    value: value && getValue(value),
-    type: getType(value),
+    value: value && this._getValue(value),
+    type: this._getType(value),
     comparisonOp: comparisonOp
   });
   return this;
@@ -457,7 +498,7 @@ Jedlik.prototype.batchGet = function() {
       if (k !== 'tablename') {
         key[k] = {};
         var value = item[k];
-        key[k][getType(value)] = value.toString();
+        key[k][that._getType(value)] = value.toString();
       };
 
     });
@@ -470,8 +511,8 @@ Jedlik.prototype.batchGet = function() {
 
 Jedlik.prototype.mapItem = function(item, keysToOmit) {
   var self = this;
-  var ret = {},
-  keysToOmit = keysToOmit || [];
+  var ret = {};
+  var keysToOmit = keysToOmit || [];
   var itemKeys = Object.keys(item);
 
   for (var i = 0; i < itemKeys.length; i++) {
@@ -486,14 +527,14 @@ Jedlik.prototype.mapItem = function(item, keysToOmit) {
         ret[key] = [];
 
         value.forEach(function(valueObj) {
-          var type = Object.keys(valueObj)[0],
-            value = valueObj[type];
-
-        ret[key].push(
-          type === 'NULL' ? null :
-          type === 'M' ? self.mapItem(value) :
-          type === 'N' ? parseFloat(value, 10) :
-          value);
+          var type = Object.keys(valueObj)[0];
+          var value = valueObj[type];
+
+          ret[key].push(
+            type === 'NULL' ? null :
+            type === 'M' ? self.mapItem(value) :
+            type === 'N' ? parseFloat(value, 10) :
+            value);
         });
       } else {
         ret[key] =

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jedlik",
-  "version": "1.0.7",
+  "version": "1.0.10",
   "description": "Fluent syntax generator for DynamoDB.",
   "main": "index.js",
   "scripts": {

package/test/fixtures/delete_hash.json

@@ -0,0 +1,8 @@
+{
+  "Key": {
+    "hashkey": {
+      "S": "hashkeyvalue"
+    }
+  },
+  "TableName": "tablename"
+}

package/test/test.js

@@ -136,12 +136,73 @@ describe('lib', function() {
           action: 'PUT'
         },
         attribute4: {
-          value: { a: { N: '123' }, b: { S: 'STR' } },
+          value: { a: { N: '123' }, b: { S: 'STR' }, c: { S: 'true' }},
           type: 'M',
           action: 'PUT'
         },
         attribute5: {
-          value: [ { M: { a: { N: '1' }, b: { S: 'S1' } } }, { M: { a: { N: '2' }, b: { S: 'S2' } } } ],
+          value: [ { M: { a: { N: '1' }, b: { S: 'S1' } } }, { M: { a: { N: '2' }, b: { S: 'S2' }, c: { S: 'true' } } } ],
+          type: 'L',
+          action: 'PUT'
+        },
+        attribute6: {
+          value: 'true',
+          type: 'S',
+          action: 'PUT'
+        },
+        attribute7: {
+          value: [ { NULL: true }, { S: 's1' }, { S: 's2' } ],
+          type: 'L',
+          action: 'PUT'
+        }
+      };
+      expect(this.jedlik
+        .attribute('attribute1', 'STR', 'PUT')
+        .attribute('attribute2', 1234)
+        .attribute('attribute3', ['s1', 's2'])
+        .attribute('attribute4', {a:123, b:'STR', c:true})
+        .attribute('attribute5', [{a:1, b:'S1'}, {a:2, b:'S2', c:true}])
+        .attribute('attribute6', true)
+        .attribute('attribute7', [null, 's1', 's2'])
+        ._data.attributes).to.deep.equal(expected);
+    });
+
+    it('should add attribute property if boolean support', function() {
+      this.jedlik = new(this.lib)(true);
+
+      var expected = {
+        attribute1: {
+          value: 'STR',
+          type: 'S',
+          action: 'PUT'
+        },
+        attribute2: {
+          value: '1234',
+          type: 'N',
+          action: 'PUT'
+        },
+        attribute3: {
+          value: ['s1', 's2'],
+          type: 'SS',
+          action: 'PUT'
+        },
+        attribute4: {
+          value: { a: { N: '123' }, b: { S: 'STR' }, c: { BOOL: true } },
+          type: 'M',
+          action: 'PUT'
+        },
+        attribute5: {
+          value: [ { M: { a: { N: '1' }, b: { S: 'S1' } } }, { M: { a: { N: '2' }, b: { S: 'S2' }, c: { BOOL: true } } } ],
+          type: 'L',
+          action: 'PUT'
+        },
+        attribute6: {
+          value: true,
+          type: 'BOOL',
+          action: 'PUT'
+        },
+        attribute7: {
+          value: [ { NULL: true }, { S: 's1' }, { S: 's2' } ],
           type: 'L',
           action: 'PUT'
         }
@@ -150,8 +211,10 @@ describe('lib', function() {
         .attribute('attribute1', 'STR', 'PUT')
         .attribute('attribute2', 1234)
         .attribute('attribute3', ['s1', 's2'])
-        .attribute('attribute4', {a:123, b:'STR'})
-        .attribute('attribute5', [{a:1, b:'S1'}, {a:2, b:'S2'}])
+        .attribute('attribute4', {a:123, b:'STR', c:true})
+        .attribute('attribute5', [{a:1, b:'S1'}, {a:2, b:'S2', c:true}])
+        .attribute('attribute6', true)
+        .attribute('attribute7', [null, 's1', 's2'])
         ._data.attributes).to.deep.equal(expected);
     });
 
@@ -203,12 +266,12 @@ describe('lib', function() {
           action: 'PUT'
         },
         attribute4: {
-          value: { a: { N: '123' }, b: { S: 'STR' } },
+          value: { a: { N: '123' }, b: { S: 'STR' }, c: { S: 'true' } },
           type: 'M',
           action: 'PUT'
         },
         attribute5: {
-          value: [ { M: { a: { N: '1' }, b: { S: 'S1' } } }, { M: { a: { N: '2' }, b: { S: 'S2' } } } ],
+          value: [ { M: { a: { N: '1' }, b: { S: 'S1' } } }, { M: { a: { N: '2' }, b: { S: 'S2' }, c: { S: 'true' } } } ],
           type: 'L',
           action: 'PUT'
         },
@@ -221,16 +284,91 @@ describe('lib', function() {
           value: true,
           type: 'NULL',
           action: 'PUT'
+        },
+        attribute8: {
+          value: 'true',
+          type: 'S',
+          action: 'PUT'
+        },
+        attribute9: {
+          value: [ { NULL: true }, { S: 's1' }, { S: 's2' } ],
+          type: 'L',
+          action: 'PUT'
         }
       };
       expect(this.jedlik
         .nullableAttribute('attribute1', 'STR', 'PUT')
         .nullableAttribute('attribute2', 1234)
         .nullableAttribute('attribute3', ['s1', 's2'])
-        .nullableAttribute('attribute4', {a:123, b:'STR'})
-        .nullableAttribute('attribute5', [{a:1, b:'S1'}, {a:2, b:'S2'}])
+        .nullableAttribute('attribute4', {a:123, b:'STR', c:true})
+        .nullableAttribute('attribute5', [{a:1, b:'S1'}, {a:2, b:'S2', c:true}])
         .nullableAttribute('attribute6', null)
         .nullableAttribute('attribute7', undefined)
+        .nullableAttribute('attribute8', true)
+        .nullableAttribute('attribute9', [null, 's1', 's2'])
+        ._data.attributes).to.deep.equal(expected);
+    });
+
+    it('should add nullable attribute property if boolean support', function() {
+      this.jedlik = new(this.lib)(true);
+
+      var expected = {
+        attribute1: {
+          value: 'STR',
+          type: 'S',
+          action: 'PUT'
+        },
+        attribute2: {
+          value: '1234',
+          type: 'N',
+          action: 'PUT'
+        },
+        attribute3: {
+          value: ['s1', 's2'],
+          type: 'SS',
+          action: 'PUT'
+        },
+        attribute4: {
+          value: { a: { N: '123' }, b: { S: 'STR' }, c: { BOOL: true } },
+          type: 'M',
+          action: 'PUT'
+        },
+        attribute5: {
+          value: [ { M: { a: { N: '1' }, b: { S: 'S1' } } }, { M: { a: { N: '2' }, b: { S: 'S2' }, c: { BOOL: true } } } ],
+          type: 'L',
+          action: 'PUT'
+        },
+        attribute6: {
+          value: true,
+          type: 'NULL',
+          action: 'PUT'
+        },
+        attribute7: {
+          value: true,
+          type: 'NULL',
+          action: 'PUT'
+        },
+        attribute8: {
+          value: true,
+          type: 'BOOL',
+          action: 'PUT'
+        },
+        attribute9: {
+          value: [ { NULL: true }, { S: 's1' }, { S: 's2' } ],
+          type: 'L',
+          action: 'PUT'
+        }
+      };
+      expect(this.jedlik
+        .nullableAttribute('attribute1', 'STR', 'PUT')
+        .nullableAttribute('attribute2', 1234)
+        .nullableAttribute('attribute3', ['s1', 's2'])
+        .nullableAttribute('attribute4', {a:123, b:'STR', c:true})
+        .nullableAttribute('attribute5', [{a:1, b:'S1'}, {a:2, b:'S2', c:true}])
+        .nullableAttribute('attribute6', null)
+        .nullableAttribute('attribute7', undefined)
+        .nullableAttribute('attribute8', true)
+        .nullableAttribute('attribute9', [null, 's1', 's2'])
         ._data.attributes).to.deep.equal(expected);
     });
   });
@@ -475,12 +613,19 @@ describe('lib', function() {
     });
   });
 
-  it('should return a valid json for delete', function() {
+  it('should return a valid json for delete when only hashkey is used', function() {
+    expect(this.jedlik
+      .tablename('tablename')
+      .hashkey('hashkey', 'hashkeyvalue')
+      .del()).to.deep.equal(require('./fixtures/delete_hash'));
+  });
+
+  it('should return a valid json for delete when both hashkey and rangekey are used', function() {
     expect(this.jedlik
       .tablename('tablename')
       .hashkey('hashkey', 'hashkeyvalue')
       .rangekey('rangekey', 'rangekeyvalue')
-      .del()).to.deep.equal(require('./fixtures/delete'));
+      .del()).to.deep.equal(require('./fixtures/delete_range'));
   });
 
   describe('getItem', function() {