Fixes #1

now the deletion of the group is a more complex transaction also taking care to clean up the group attribute for all the entities that were in the group before deleting it.

Author: nopbyte

lib/entity-connection-pool.js

@@ -1,4 +1,4 @@
-var db = null;
+var db;
 var EntityStorage = require('./level-storage');
 var console = require('./log');
 

lib/level-storage.js

@@ -147,7 +147,7 @@ function updateSomething(action_type, pk, data, transaction, commit) {
               if (error)
                 transaction.rollback(reject.bind(this, createError(500, 'cannot read ' + action_type + ' with pk ' + pkToString(pk) + ' after creating it')));
               else {
-                console.log(action_type + 'executed successfully. Value ' + JSON.stringify(value));
+                console.log(action_type + ' updated successfully. Value ' + JSON.stringify(value));
                 if (commit && commit === true)
                   transaction.commit(resolve.bind(this, value));
                 else
@@ -291,9 +291,54 @@ LevelStorage.prototype.updateGroupPromise = function (group_name, owner, data) {
 
 LevelStorage.prototype.deleteGroupPromise = function (group_name, owner) {
   console.log("arguments for deleteGroupPromise leveldb " + JSON.stringify(arguments));
-  var pk = buildGroupPk(group_name, owner);
-  return deleteSomething("groups", pk, transaction(this.groups), true);
 
+  function rollback(t1, t2, callback) {
+    t1.rollback(t2.rollback(callback));
+  }
+  var that = this;
+  var group, entity;
+  return new Promise(function (resolve, reject) {
+    var group_pk = buildGroupPk(group_name, owner);
+    var t_groups = transaction(that.groups);
+    var t_entities = transaction(that.entities);
+    readSomething("groups", group_pk, t_groups, false)
+      .then(function (group) {
+        var entities = group.entities;
+        var readEntities = [];
+        if (entities && entities.length > 0) {
+          entities.forEach(function (entity_pk) {
+            readEntities.push(readSomething("entities", entity_pk, t_entities, false));
+          });
+          return Promise.all(readEntities);
+        } else {
+          return Promise.resolve([]); //return an empty set of entities so that the promise chain keeps going :)
+        }
+      }).then(function (entities) {
+        var ps = [];
+        entities.forEach(function (e) {
+          ps.push(new Promise(function (re, rej) {
+            e.groups = e.groups.filter(function (v) {
+              return (v.group_name !== group_name || v.owner !== owner);
+            });
+            updateSomething("entities", getPk("entities", e), e, t_entities, false).then(re, rej);
+          }));
+        });
+        return Promise.all(ps);
+      }).then(function (res) {
+        console.log("finished updating entities to remove group from their attributes");
+        console.log("attempting to delete group " + JSON.stringify(group_pk));
+        return deleteSomething("groups", group_pk, t_groups, false);
+      }).then(function () {
+        t_entities.commit(function () {
+          t_groups.commit(function () {
+            resolve();
+          });
+        });
+      }).catch(function rej(reason) {
+        console.log('level storage rejecting ' + reason);
+        return rollback(t_entities, t_groups, reject.bind(this, reason));
+      });
+  });
 };
 
 LevelStorage.prototype.addEntityToGroupPromise = function (group_name, owner, entity_id, entity_type) {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "agile-idm-entity-storage",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "",
   "main": "index.js",
   "directories": {

tests/level-storage-test.js

@@ -591,6 +591,45 @@ describe('LevelStorage', function () {
         });
     });
 
+    it('should remove group references in entities after deleting it', function (done) {
+      var storage = createLevelStorage();
+      var owner = "1";
+      var entity_id = "2";
+      var entity_type = "user";
+      var data = {
+        "name": "string",
+        "token": "123"
+      };
+      var group;
+      var group_name = "mygroup";
+      storage.createGroupPromise(group_name, owner)
+        .then(function (g) {
+          group = g;
+          return storage.createEntityPromise(entity_id, entity_type, owner, data)
+        })
+        .then(function (entity) {
+          return storage.addEntityToGroupPromise(group.group_name, group.owner, entity_id, entity_type);
+        }).then(function (result) {
+
+          return storage.deleteGroupPromise(group_name, owner);
+        }).then(function (result) {
+          return storage.readEntityPromise(entity_id, entity_type);
+        }).then(function (entity) {
+          if (entity.groups) {
+            var r = entity.groups.filter(function (v) {
+              return (v.group_name == group_name && v.owner === owner);
+            });
+            if (r.length === 0) {
+              storage.cleanDb(done);
+            } else {
+              reject(new Error("group not removed! " + JSON.stringify(entity)));
+            }
+          }
+        }).catch(function reject(error) {
+          throw error;
+        });
+    });
+
     it('should reject with 404 error when attempting to place an exitent entity in a group is not there', function (done) {
       var storage = createLevelStorage();
       var owner = "1";