Added .returning()

This MR allows callers to get the original object as it was before an update is made or the new object as it is after the update. Since TransactWriteItems does not support this feature, additional logic has been added to nodenamo to support this addition. Returning an old object does not incur additional cost. Returning a new object, however, involves an additional get query. The returned object, if any, is strongly consistent.
mappies · Jul 10, 2024 · 684bd51 · 684bd51
1 parent 3724d9a
commit 684bd51
Show file tree

Hide file tree

Showing 28 changed files with 644 additions and 43 deletions.
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "nodenamo",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "A powerful ORM for DynamoDb",
   "main": "dist/index.js",
   "typings": "dist/index",

diff --git a/spec/acceptance/customNameTest.spec.ts b/spec/acceptance/customNameTest.spec.ts
@@ -2,7 +2,7 @@ import {assert as assert} from 'chai';
 import { DBTable, DBColumn } from '../../src';
 import { NodeNamo } from '../../src/nodeNamo';
 import Config from './config';
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { ReturnValue } from '../../src/interfaces/returnValue';
 
 @DBTable({name:'nodenamo_acceptance_targetNameTest'})
 class User
@@ -261,7 +261,9 @@ describe('Custom-name tests', function ()
 
         user.name = 'This Three';
         user['extra'] = 'invalid';
-        await nodenamo.update(user).from(User).execute();
+        let result = await nodenamo.update(user).from(User).execute();
+
+        assert.isUndefined(result);
 
         user = await nodenamo.get(3).from(User).execute();
         assert.deepEqual(user, { id: 3, name: 'This Three', account: 2000, created: 2018, department: 'development', enabled: false });
@@ -300,6 +302,31 @@ describe('Custom-name tests', function ()
         assert.deepEqual(user, { id: 6, name: '', account: 3000, created: 2020, department: 'hr', enabled: true });
     });
 
+    it('Update an item - return AllOld', async () =>
+    {
+        let originalUser = await nodenamo.get(2).from(User).execute<User>();
+
+        let result = await nodenamo.update({id: 2, name: 'Newer Two'}).from(User).returning(ReturnValue.AllOld).execute();
+
+        assert.deepEqual(result, originalUser);
+    });
+
+    it('Update an item - return AllNew', async () =>
+    {
+        let originalUser = await nodenamo.get(2).from(User).execute<User>();
+
+        let result = await nodenamo.update({id: 2, name: 'Newest Two'}).from(User).returning(ReturnValue.AllNew).execute();
+
+        assert.deepEqual(result, {...originalUser, name: 'Newest Two'});
+    });
+
+    it('Update an item - return None', async () =>
+    {
+        let result = await nodenamo.update({id: 2, name: 'Newer Two'}).from(User).returning(ReturnValue.None).execute();
+
+        assert.isUndefined(result);
+    });
+
     it('On item', async () =>
     {
         let user = await nodenamo.get(6).from(User).execute<User>();

diff --git a/spec/acceptance/globalTableTest.spec.ts b/spec/acceptance/globalTableTest.spec.ts
@@ -209,7 +209,9 @@ describe('Global table tests', function ()
         assert.deepEqual(book, { id: 2, title: 'Another Book' });
 
         user.name = 'This Two';
-        await nodenamo.update(user).from(User).execute();
+        let result = await nodenamo.update(user).from(User).execute();
+
+        assert.isUndefined(result);
 
         user = await nodenamo.get(2).from(User).execute();
         assert.deepEqual(user, { id: 2, name: 'This Two' });

diff --git a/spec/acceptance/hashRangePairTest.spec.ts b/spec/acceptance/hashRangePairTest.spec.ts
@@ -2,7 +2,7 @@ import {assert as assert} from 'chai';
 import { DBTable, DBColumn } from '../../src';
 import { NodeNamo } from '../../src/nodeNamo';
 import Config from './config';
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { ReturnValue } from '../../src/interfaces/returnValue';
 
 @DBTable({name:'nodenamo_acceptance_hashRangePairTest'})
 class User
@@ -283,7 +283,9 @@ describe('Hash-range pair tests', function ()
 
         user.name = 'This Three';
         user['extra'] = 'invalid';
-        await nodenamo.update(user).from(User).execute();
+        let result = await nodenamo.update(user).from(User).execute();
+
+        assert.isUndefined(result);
 
         user = await nodenamo.get(3).from(User).execute();
         assert.deepEqual(user, { id: 3, name: 'This Three', account: 2000, created: 2018, parentId: 300 });
@@ -361,6 +363,45 @@ describe('Hash-range pair tests', function ()
         assert.deepEqual(user, { id: 6, name: '', account: 3000, created: 2020, parentId: 600 });
     });
 
+    it('Update an item - return AllOld', async () =>
+    {
+        let originalUser = await nodenamo.get(2).from(User).execute<User>();
+
+        let result = await nodenamo.update({id: 2, name: 'Newer Two'}).from(User).returning(ReturnValue.AllOld).execute();
+
+        assert.deepEqual(result, originalUser);
+    });
+
+    it('Update an item - return AllNew', async () =>
+    {
+        let originalUser = await nodenamo.get(2).from(User).execute<User>();
+
+        let result = await nodenamo.update({id: 2, name: 'Newest Two'}).from(User).returning(ReturnValue.AllNew).execute();
+
+        assert.deepEqual(result, {...originalUser, name: 'Newest Two'});
+    });
+
+    it('Update an item - return None', async () =>
+    {
+        let result = await nodenamo.update({id: 2, name: 'Newer Two'}).from(User).returning(ReturnValue.None).execute();
+
+        assert.isUndefined(result);
+    });
+
+    it('Update an item - with all combinations', async () =>
+    {
+        let originalUser = await nodenamo.get(2).from(User).execute<User>();
+
+        let result = await nodenamo.update({id: 2, name: 'Another Two'})
+                                   .from(User)
+                                   .where('#account=:account', {'#account': 'account'}, {':account': originalUser.account})
+                                   .returning(ReturnValue.AllOld)
+                                   .withVersionCheck()
+                                   .execute();
+
+        assert.deepEqual(result, originalUser);
+    });
+
     it('On item', async () =>
     {
         let user = await nodenamo.get(6).from(User).execute<User>();

diff --git a/spec/acceptance/hashRangeTest.spec.ts b/spec/acceptance/hashRangeTest.spec.ts
@@ -2,7 +2,7 @@ import {assert as assert} from 'chai';
 import { DBTable, DBColumn } from '../../src';
 import { NodeNamo } from '../../src/nodeNamo';
 import Config from './config';
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { ReturnValue } from '../../src/interfaces/returnValue';
 
 @DBTable({name:'nodenamo_acceptance_hashRangeTest'})
 class User
@@ -361,7 +361,9 @@ describe('Hash-range tests', function ()
 
         user.name = 'This Three';
         user['extra'] = 'invalid';
-        await nodenamo.update(user).from(User).execute();
+        let result = await nodenamo.update(user).from(User).execute();
+
+        assert.isUndefined(result);
 
         user = await nodenamo.get(3).from(User).execute();
         assert.deepEqual(user, { id: 3, name: 'This Three', account: 2000, created: 2018 });
@@ -440,6 +442,45 @@ describe('Hash-range tests', function ()
         assert.deepEqual(user, { id: 6, name: '', account: 3000, created: 2020 });
     });
 
+    it('Update an item - return AllOld', async () =>
+    {
+        let originalUser = await nodenamo.get(2).from(User).execute<User>();
+
+        let result = await nodenamo.update({id: 2, name: 'Newer Two'}).from(User).returning(ReturnValue.AllOld).execute();
+
+        assert.deepEqual(result, originalUser);
+    });
+
+    it('Update an item - return AllNew', async () =>
+    {
+        let originalUser = await nodenamo.get(2).from(User).execute<User>();
+
+        let result = await nodenamo.update({id: 2, name: 'Newest Two'}).from(User).returning(ReturnValue.AllNew).execute();
+
+        assert.deepEqual(result, {...originalUser, name: 'Newest Two'});
+    });
+
+    it('Update an item - return None', async () =>
+    {
+        let result = await nodenamo.update({id: 2, name: 'Newer Two'}).from(User).returning(ReturnValue.None).execute();
+
+        assert.isUndefined(result);
+    });
+
+    it('Update an item - with all combinations', async () =>
+    {
+        let originalUser = await nodenamo.get(2).from(User).execute<User>();
+
+        let result = await nodenamo.update({id: 2, name: 'Another Two'})
+                                   .from(User)
+                                   .where('#account=:account', {'#account': 'account'}, {':account': originalUser.account})
+                                   .returning(ReturnValue.AllOld)
+                                   .withVersionCheck()
+                                   .execute();
+
+        assert.deepEqual(result, originalUser);
+    });
+
     it('On item', async () =>
     {
         let user = await nodenamo.get(6).from(User).execute<User>();

diff --git a/spec/acceptance/hashTest.spec.ts b/spec/acceptance/hashTest.spec.ts
@@ -2,7 +2,7 @@ import {assert as assert} from 'chai';
 import { DBTable, DBColumn } from '../../src';
 import { NodeNamo } from '../../src/nodeNamo';
 import Config from './config';
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { ReturnValue } from '../../src/interfaces/returnValue';
 
 @DBTable({name:'nodenamo_acceptance_hashTest'})
 class User
@@ -288,7 +288,9 @@ describe('Hash tests', function ()
 
         user.name = 'This Three';
         user['extra'] = 'invalid';
-        await nodenamo.update(user).from(User).execute();
+        let result = await nodenamo.update(user).from(User).execute();
+
+        assert.isUndefined(result);
 
         user = await nodenamo.get(3).from(User).execute();
         assert.deepEqual(user, { id: 3, name: 'This Three', account: 3000 });
@@ -367,6 +369,45 @@ describe('Hash tests', function ()
         assert.deepEqual((await nodenamo.list().from(User).execute()).items.length, 6);
     });
 
+    it('Update an item - return AllOld', async () =>
+    {
+        let originalUser = await nodenamo.get(2).from(User).execute<User>();
+
+        let result = await nodenamo.update({id: 2, name: 'Newer Two'}).from(User).returning(ReturnValue.AllOld).execute();
+
+        assert.deepEqual(result, originalUser);
+    });
+
+    it('Update an item - return AllNew', async () =>
+    {
+        let originalUser = await nodenamo.get(2).from(User).execute<User>();
+
+        let result = await nodenamo.update({id: 2, name: 'Newest Two'}).from(User).returning(ReturnValue.AllNew).execute();
+
+        assert.deepEqual(result, {...originalUser, name: 'Newest Two'});
+    });
+
+    it('Update an item - return None', async () =>
+    {
+        let result = await nodenamo.update({id: 2, name: 'Newer Two'}).from(User).returning(ReturnValue.None).execute();
+
+        assert.isUndefined(result);
+    });
+
+    it('Update an item - with all combinations', async () =>
+    {
+        let originalUser = await nodenamo.get(2).from(User).execute<User>();
+
+        let result = await nodenamo.update({id: 2, name: 'Another Two'})
+                                   .from(User)
+                                   .where('#account=:account', {'#account': 'account'}, {':account': originalUser.account})
+                                   .returning(ReturnValue.AllOld)
+                                   .withVersionCheck()
+                                   .execute();
+
+        assert.deepEqual(result, originalUser);
+    });
+
     it('On item', async () =>
     {
         let user = await nodenamo.get(6).from(User).execute<User>();

diff --git a/spec/acceptance/idTest.spec.ts b/spec/acceptance/idTest.spec.ts
@@ -2,6 +2,7 @@ import {assert as assert} from 'chai';
 import { DBTable, DBColumn } from '../../src';
 import { NodeNamo } from '../../src/nodeNamo';
 import Config from './config';
+import { ReturnValue } from '../../src/interfaces/returnValue';
 
 @DBTable({name:'nodenamo_acceptance_idTest'})
 class User
@@ -232,8 +233,10 @@ describe('ID tests', function ()
 
         user3.name = 'This Three';
         user3['extra'] = 'invalid';
-        await nodenamo.update(user3).from(User).execute();
+        let result = await nodenamo.update(user3).from(User).execute();
 
+        assert.isUndefined(result);
+
         user = await nodenamo.get(3).from(User).execute();
         assert.deepEqual(user, {id:3, name: 'This Three', description: 'Description 3', secret: undefined, obj:{array:[], bool:true, empty:'', num:1, obj:{n:1,e:''}, str:'string'}});
     });
@@ -272,6 +275,31 @@ describe('ID tests', function ()
         assert.deepEqual(user, {id:4, name: 'Some Four', description: '', secret: undefined, obj:undefined});
     });
 
+    it('Update an item - return AllOld', async () =>
+    {
+        let originalUser = await nodenamo.get(2).from(User).execute<User>();
+
+        let result = await nodenamo.update({id: 2, name: 'New Two'}).from(User).returning(ReturnValue.AllOld).execute();
+
+        assert.deepEqual(result, originalUser);
+    });
+
+    it('Update an item - return AllNew', async () =>
+    {
+        let originalUser = await nodenamo.get(2).from(User).execute<User>();
+
+        let result = await nodenamo.update({id: 2, name: 'Newest Two'}).from(User).returning(ReturnValue.AllNew).execute();
+
+        assert.deepEqual(result, {...originalUser, name: 'Newest Two'});
+    });
+
+    it('Update an item - return None', async () =>
+    {
+        let result = await nodenamo.update({id: 2, name: 'Newer Two'}).from(User).returning(ReturnValue.None).execute();
+
+        assert.isUndefined(result);
+    });
+
     it('On item', async () =>
     {
         let user = await nodenamo.get(4).from(User).execute<User>();

diff --git a/spec/acceptance/indexConsistentTest.spec.ts b/spec/acceptance/indexConsistentTest.spec.ts
@@ -2,7 +2,6 @@ import {assert as assert} from 'chai';
 import { DBTable, DBColumn } from '../../src';
 import { NodeNamo } from '../../src/nodeNamo';
 import Config from './config';
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
 import { Const } from '../../src/const';
 
 @DBTable({name:'nodenamo_acceptance_indexConsistentTest'})

diff --git a/spec/acceptance/lastEvaluatedKeyWithFilterAndPagingTest.spec.ts b/spec/acceptance/lastEvaluatedKeyWithFilterAndPagingTest.spec.ts
@@ -2,7 +2,6 @@ import {assert as assert} from 'chai';
 import { DBTable, DBColumn } from '../../src';
 import { NodeNamo } from '../../src/nodeNamo';
 import Config from './config';
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
 
 @DBTable({name:'nodenamo_acceptance_lastEvaluatedKeyWithFilterAndPagingTest'})
 class User

diff --git a/spec/acceptance/marshallTest.spec.ts b/spec/acceptance/marshallTest.spec.ts
@@ -97,7 +97,9 @@ describe('Marshall tests', function ()
 
         person.children.push(person2);
 
-        await nodenamo.update(person).from(Person).execute();
+        let result = await nodenamo.update(person).from(Person).execute();
+
+        assert.isUndefined(result);
 
         person = await nodenamo.get(0).from(Person).execute();
         assert.equal(person.children.length, 2);

diff --git a/spec/acceptance/multiValuesHashRangeTest.spec.ts b/spec/acceptance/multiValuesHashRangeTest.spec.ts
@@ -2,7 +2,6 @@ import {assert as assert} from 'chai';
 import { DBTable, DBColumn } from '../../src';
 import { NodeNamo } from '../../src/nodeNamo';
 import Config from './config';
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
 
 @DBTable({name:'nodenamo_acceptance_multiValuesHashRangeTest'})
 class User
@@ -270,7 +269,9 @@ describe('Multi-values Hash/Range tests', function ()
 
         user.name = 'This Three';
         user['extra'] = 'invalid';
-        await nodenamo.update(user).from(User).execute();
+        let result = await nodenamo.update(user).from(User).execute();
+
+        assert.isUndefined(result);
 
         user = await nodenamo.get(3).from(User).execute();
         assert.deepEqual(user, new User({ id: 3, name: 'This Three', roles: ['user', 'admin'], departments: ['IT', 'HR'], createdTimestamp: 2014 }));