additional entity method updates

Author: jeremydaly

__tests__/bootstrap-tests.js

@@ -23,7 +23,8 @@ module.exports.DynamoDB = new AWS.DynamoDB({
 module.exports.DocumentClient = new AWS.DynamoDB.DocumentClient({
   endpoint: 'http://localhost:4567',
   region: 'us-east-1',
-  credentials: new AWS.Credentials({ accessKeyId: 'test', secretAccessKey: 'test' })
+  credentials: new AWS.Credentials({ accessKeyId: 'test', secretAccessKey: 'test' }),
+  // convertEmptyValues: true
 })
 
 // Delay helper

__tests__/delete.unit.test.js

@@ -22,7 +22,7 @@ const TestEntity = new Entity({
 describe('delete',()=>{
 
   it('gets the key from inputs (sync)', () => {
-    let { TableName, Key } = TestEntity.deleteSync({ pk: 'test-pk', sk: 'test-sk' })
+    let { TableName, Key } = TestEntity.generateDeleteParams({ pk: 'test-pk', sk: 'test-sk' })
     expect(TableName).toBe('test-table')
     expect(Key).toEqual({ pk: 'test-pk', sk: 'test-sk' })
   })
@@ -34,7 +34,7 @@ describe('delete',()=>{
   })
 
   it('gets the key from input aliases (sync)', () => {
-    let { TableName, Key } = TestEntity.deleteSync({ email: 'test-pk', sort: 'test-sk' })
+    let { TableName, Key } = TestEntity.generateDeleteParams({ email: 'test-pk', sort: 'test-sk' })
     expect(TableName).toBe('test-table')
     expect(Key).toEqual({ pk: 'test-pk', sk: 'test-sk' })
   })
@@ -46,7 +46,7 @@ describe('delete',()=>{
   })
 
   it('filters out extra data (sync)', () => {
-    let { TableName, Key } = TestEntity.deleteSync({ pk: 'test-pk', sk: 'test-sk', test: 'test' })
+    let { TableName, Key } = TestEntity.generateDeleteParams({ pk: 'test-pk', sk: 'test-sk', test: 'test' })
     expect(TableName).toBe('test-table')
     expect(Key).toEqual({ pk: 'test-pk', sk: 'test-sk' })
   })
@@ -58,7 +58,7 @@ describe('delete',()=>{
   })
 
   it('coerces key values to correct types (sync)', () => {
-    let { TableName, Key } = TestEntity.deleteSync({ pk: 1, sk: true })
+    let { TableName, Key } = TestEntity.generateDeleteParams({ pk: 1, sk: true })
     expect(TableName).toBe('test-table')
     expect(Key).toEqual({ pk: '1', sk: 'true' })
   })
@@ -70,7 +70,7 @@ describe('delete',()=>{
   })
 
   it('fails with undefined input (sync)', () => {
-    expect(() => TestEntity.deleteSync()).toThrow(`'pk' or 'email' is required`)
+    expect(() => TestEntity.generateDeleteParams()).toThrow(`'pk' or 'email' is required`)
   })
 
   it('fails with undefined input (async)', () => {

__tests__/get.unit.test.js

@@ -40,7 +40,7 @@ const TestEntity2 = new Entity({
 describe('get',()=>{
 
   it('gets the key from inputs (sync)', async () => {
-    const { TableName, Key } = TestEntity.getSync({ pk: 'test-pk', sk: 'test-sk' })    
+    const { TableName, Key } = TestEntity.generateGetParams({ pk: 'test-pk', sk: 'test-sk' })    
     expect(TableName).toBe('test-table')
     expect(Key).toEqual({ pk: 'test-pk', sk: 'test-sk' })
   })
@@ -52,7 +52,7 @@ describe('get',()=>{
   })
 
   it('gets the key from input aliases (sync)', async () => {
-    let { TableName, Key } = TestEntity.getSync({ email: 'test-pk', sort: 'test-sk' })
+    let { TableName, Key } = TestEntity.generateGetParams({ email: 'test-pk', sort: 'test-sk' })
     expect(TableName).toBe('test-table')
     expect(Key).toEqual({ pk: 'test-pk', sk: 'test-sk' })
   })
@@ -64,7 +64,7 @@ describe('get',()=>{
   })
 
   it('filters out extra data (sync)', async () => {
-    let { TableName, Key } = TestEntity.getSync({ pk: 'test-pk', sk: 'test-sk', test: 'test' })
+    let { TableName, Key } = TestEntity.generateGetParams({ pk: 'test-pk', sk: 'test-sk', test: 'test' })
     expect(TableName).toBe('test-table')
     expect(Key).toEqual({ pk: 'test-pk', sk: 'test-sk' })
   })
@@ -76,7 +76,7 @@ describe('get',()=>{
   })
 
   it('coerces key values to correct types (sync)', async () => {
-    let { TableName, Key } = TestEntity.getSync({ pk: 1, sk: true })
+    let { TableName, Key } = TestEntity.generateGetParams({ pk: 1, sk: true })
     expect(TableName).toBe('test-table')
     expect(Key).toEqual({ pk: '1', sk: 'true' })
   })
@@ -88,31 +88,31 @@ describe('get',()=>{
   })
 
   it('fails with undefined input (sync)', () => {
-    expect(() => TestEntity.getSync()).toThrow(`'pk' or 'email' is required`)
+    expect(() => TestEntity.generateGetParams()).toThrow(`'pk' or 'email' is required`)
   })
 
   it('fails with undefined input (async)', async () => {
     expect(TestEntity.get()).rejects.toBe(`'pk' or 'email' is required`)
   })
 
   it('fails when missing the sortKey (sync)', () => {
-    expect(() => TestEntity.getSync({ pk: 'test-pk' })).toThrow(`'sk' or 'sort' is required`)
+    expect(() => TestEntity.generateGetParams({ pk: 'test-pk' })).toThrow(`'sk' or 'sort' is required`)
   })
 
   it('fails when missing the sortKey (async)', () => {
     expect(TestEntity.get({ pk: 'test-pk' })).rejects.toBe(`'sk' or 'sort' is required`)
   })
 
   it('fails when missing partitionKey (no alias) (sync)', () => {
-    expect(() => TestEntity2.getSync()).toThrow(`'pk' is required`)
+    expect(() => TestEntity2.generateGetParams()).toThrow(`'pk' is required`)
   })
 
   it('fails when missing partitionKey (no alias) (async)', () => {
     expect(TestEntity2.get()).rejects.toBe(`'pk' is required`)
   })
 
   it('fails when missing the sortKey (no alias) (sync)', () => {
-    expect(() => TestEntity2.getSync({ pk: 'test-pk' })).toThrow(`'sk' is required`)
+    expect(() => TestEntity2.generateGetParams({ pk: 'test-pk' })).toThrow(`'sk' is required`)
   })
 
   it('fails when missing the sortKey (no alias) (async)', () => {

__tests__/put.unit.test.js

@@ -71,7 +71,7 @@ const TestEntity3 = new Entity({
 describe('put',()=>{
 
   it('creates basic item',() => {
-    let { TableName, Item } = TestEntity.putSync({ pk: 'test-pk', sk: 'test-sk' })
+    let { TableName, Item } = TestEntity.generatePutParams({ pk: 'test-pk', sk: 'test-sk' })
 
     expect(Item.pk).toBe('test-pk')
     expect(Item.sk).toBe('test-sk')
@@ -82,7 +82,7 @@ describe('put',()=>{
   })
 
   it('creates item with aliases',() => {
-    let { Item } = TestEntity.putSync({ email: 'test-pk', sort: 'test-sk', count: 5 })
+    let { Item } = TestEntity.generatePutParams({ email: 'test-pk', sort: 'test-sk', count: 5 })
 
     expect(Item.pk).toBe('test-pk')
     expect(Item.sk).toBe('test-sk')
@@ -94,7 +94,7 @@ describe('put',()=>{
   })
 
   it('creates item with default override',() => {
-    let { Item } = TestEntity.putSync({ pk: 'test-pk', sk: 'test-sk', test_string: 'different value' })
+    let { Item } = TestEntity.generatePutParams({ pk: 'test-pk', sk: 'test-sk', test_string: 'different value' })
     expect(Item.pk).toBe('test-pk')
     expect(Item.sk).toBe('test-sk')
     expect(Item._tp).toBe('TestEntity')
@@ -104,7 +104,7 @@ describe('put',()=>{
   })
 
   it('creates item with saved composite field',() => {
-    let { Item } = TestEntity2.putSync({
+    let { Item } = TestEntity2.generatePutParams({
       pk: 'test-pk',
       test_composite: 'test',
     })  
@@ -113,17 +113,18 @@ describe('put',()=>{
   })
 
   it('creates item that ignores field with no value',() => {
-    let { Item } = TestEntity2.putSync({
+    let { Item } = TestEntity2.generatePutParams({
       pk: 'test-pk',
       test_composite: undefined
     })
+    
     expect(Item.pk).toBe('test-pk')
     expect(Item).not.toHaveProperty('sk')
     expect(Item).not.toHaveProperty('test_composite')
   })
 
   it('creates item that overrides composite key',() => {
-    let { Item } = TestEntity2.putSync({
+    let { Item } = TestEntity2.generatePutParams({
       pk: 'test-pk',
       sk: 'override',
       test_composite: 'test',
@@ -136,7 +137,7 @@ describe('put',()=>{
   })
 
   it('creates item that generates composite key',() => {
-    let { Item } = TestEntity2.putSync({
+    let { Item } = TestEntity2.generatePutParams({
       pk: 'test-pk',
       test_composite: 'test',
       test_composite2: 'test2'
@@ -148,91 +149,91 @@ describe('put',()=>{
   })
 
   it('fails with undefined input', () => {
-    expect(() => TestEntity.putSync()).toThrow(`'pk' or 'email' is required`)
+    expect(() => TestEntity.generatePutParams()).toThrow(`'pk' or 'email' is required`)
   })
 
   it('fails when using an undefined schema field', () => {
-    expect(() => TestEntity.putSync({
+    expect(() => TestEntity.generatePutParams({
       'pk': 'test-pk',
       'sk': 'test-sk',
       'unknown': '?'
     })).toThrow(`Field 'unknown' does not have a mapping or alias`)
   })
 
   it('fails when invalid string provided with no coercion', () => {
-    expect(() => TestEntity.putSync({
+    expect(() => TestEntity.generatePutParams({
       'pk': 'test-pk',
       'sk': 'test-sk',
       'test_string': 1
     })).toThrow(`'test_string' must be of type string`)
   })
 
   it('fails when invalid boolean provided with no coercion', () => {
-    expect(() => TestEntity.putSync({
+    expect(() => TestEntity.generatePutParams({
       'pk': 'test-pk',
       'sk': 'test-sk',
       'test_boolean': 'x'
     })).toThrow(`'test_boolean' must be of type boolean`)
   })
 
   it('fails when invalid number provided with no coercion', () => {
-    expect(() => TestEntity.putSync({
+    expect(() => TestEntity.generatePutParams({
       'pk': 'test-pk',
       'sk': 'test-sk',
       'test_number': 'x'
     })).toThrow(`'test_number' must be of type number`)
   })
 
   it('fails when invalid number cannot be coerced', () => {
-    expect(() => TestEntity.putSync({
+    expect(() => TestEntity.generatePutParams({
       'pk': 'test-pk',
       'sk': 'test-sk',
       'test_number_coerce': 'x1'
     })).toThrow(`Could not convert 'x1' to a number for 'test_number_coerce'`)
   })
 
   it('fails when invalid array provided with no coercion', () => {
-    expect(() => TestEntity.putSync({
+    expect(() => TestEntity.generatePutParams({
       'pk': 'test-pk',
       'sk': 'test-sk',
       'test_list': 'x'
     })).toThrow(`'test_list' must be a list (array)`)
   })
 
   it('fails when invalid map provided', () => {
-    expect(() => TestEntity.putSync({
+    expect(() => TestEntity.generatePutParams({
       'pk': 'test-pk',
       'sk': 'test-sk',
       'test_map': 'x'
     })).toThrow(`'test_map' must be a map (object)`)
   })
 
   it('fails when set contains different types', () => {
-    expect(() => TestEntity.putSync({
+    expect(() => TestEntity.generatePutParams({
       'pk': 'test-pk',
       'sk': 'test-sk',
       'test_string_set_type': [1,2,3]
     })).toThrow(`'test_string_set_type' must be a valid set (array) containing only string types`)
   })
 
   it('fails when set contains multiple types', () => {
-    expect(() => TestEntity.putSync({
+    expect(() => TestEntity.generatePutParams({
       'pk': 'test-pk',
       'sk': 'test-sk',
       'test_string_set': ['test',1]
     })).toThrow(`String Set contains Number value`)
   })
 
   it('fails when set coerces array and doesn\'t match type', () => {
-    expect(() => TestEntity.putSync({
+    expect(() => TestEntity.generatePutParams({
       'pk': 'test-pk',
       'sk': 'test-sk',
       'test_number_set_type_coerce': "1,2,3"
     })).toThrow(`'test_number_set_type_coerce' must be a valid set (array) of type number`)
   })
 
   it('coerces array into set', () => {
-    let { Item } = TestEntity.putSync({
+    let { Item } = TestEntity.generatePutParams({
       'pk': 'test-pk',
       'sk': 'test-sk',
       'test_string_set_type_coerce': "1,2,3"
@@ -241,15 +242,15 @@ describe('put',()=>{
   })
 
   it('fails when set doesn\'t contain array with no coercion', () => {
-    expect(() => TestEntity.putSync({
+    expect(() => TestEntity.generatePutParams({
       'pk': 'test-pk',
       'sk': 'test-sk',
       'test_string_set': 'test'
     })).toThrow(`'test_string_set' must be a valid set (array)`)
   })
 
   it('fails when missing a required field', () => {
-    expect(() => TestEntity3.putSync({
+    expect(() => TestEntity3.generatePutParams({
       'pk': 'test-pk',
       'test2': 'test'
     })).toThrow(`'test' is a required field`)