@restorecommerce/resource-base-interface 0.2.1 → 0.2.6

package/lib/core/ResourcesAPI.js

@@ -1,21 +1,28 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResourcesAPIBase = void 0;
-const _ = require("lodash");
-const bluebird = require("bluebird");
+const _ = __importStar(require("lodash"));
 const chassis_srv_1 = require("@restorecommerce/chassis-srv");
-const uuid = require("uuid");
-const redis = require("redis");
-bluebird.promisifyAll(redis.RedisClient.prototype);
+const uuid = __importStar(require("uuid"));
 let redisClient;
 const Strategies = {
     INCREMENT: 'increment',
@@ -29,22 +36,22 @@ const uuidGen = () => {
 const isEmptyObject = (obj) => {
     return !Object.keys(obj).length;
 };
-const setDefaults = (obj, collectionName) => __awaiter(void 0, void 0, void 0, function* () {
+const setDefaults = async (obj, collectionName) => {
     const o = obj;
     if (_.isEmpty(o.meta)) {
         throw new chassis_srv_1.errors.InvalidArgument('Object does not contain ownership information');
     }
     const now = Date.now();
     if (redisClient) {
-        const values = yield redisClient.hgetallAsync(collectionName);
+        const values = await redisClient.hGetAll(collectionName);
         if (values) {
             for (let field in values) {
                 const strategy = values[field];
                 switch (strategy) {
                     case Strategies.INCREMENT:
                         const key = collectionName + ':' + field;
-                        o[field] = yield redisClient.getAsync(key);
-                        yield redisClient.incrAsync(key);
+                        o[field] = await redisClient.get(key);
+                        await redisClient.incr(key);
                         break;
                     case Strategies.UUID:
                         o[field] = uuidGen();
@@ -53,7 +60,7 @@ const setDefaults = (obj, collectionName) => __awaiter(void 0, void 0, void 0, f
                         o[field] = uuidGen();
                         break;
                     case Strategies.TIMESTAMP:
-                        o[field] = yield redisClient.timeAsync()[0];
+                        o[field] = await redisClient.time()[0];
                         break;
                 }
             }
@@ -67,7 +74,7 @@ const setDefaults = (obj, collectionName) => __awaiter(void 0, void 0, void 0, f
         o.id = uuidGen();
     }
     return o;
-});
+};
 const updateMetadata = (docMeta, newDoc) => {
     if (_.isEmpty(newDoc.meta)) {
         // docMeta.owner = newDoc.owner;
@@ -133,22 +140,14 @@ class ResourcesAPIBase {
             this.requiredFields = fieldHandlerConf.requiredFields;
         }
         // values for Redis hash set
-        const hashValues = [];
-        hashValues.push(collectionName);
         for (let field in strategyCfg) {
             const strategy = strategyCfg[field].strategy;
-            hashValues.push(field);
-            hashValues.push(strategy);
+            redisClient.hSet(collectionName, field, strategy);
             switch (strategy) {
                 case Strategies.INCREMENT:
-                    let startingValue;
                     // check if value already exists in redis
-                    redisClient.get(`${collectionName}:${field}`, (err, reply) => {
-                        if (err) {
-                            throw err;
-                        }
-                        startingValue = reply;
-                    });
+                    let startingValue;
+                    startingValue = redisClient.get(`${collectionName}:${field}`).then((val) => val);
                     if (!startingValue) {
                         if (strategyCfg[field].startingValue) {
                             startingValue = Number(strategyCfg[field].startingValue) != NaN ?
@@ -157,27 +156,13 @@ class ResourcesAPIBase {
                         else {
                             startingValue = '0';
                         }
-                        redisClient.set(`${collectionName}:${field}`, startingValue, (err, reply) => {
-                            if (err) {
-                                throw err;
-                            }
-                            if (reply != 'OK') {
-                                throw Error('Unexpected reply from Redis: ' + reply);
-                            }
-                        });
+                        redisClient.set(`${collectionName}:${field}`, startingValue).then((val) => val);
                     }
                     break;
                 default:
                     break;
             }
         }
-        if (redisClient) {
-            redisClient.hset(hashValues, (err, reply) => {
-                if (err) {
-                    throw err;
-                }
-            });
-        }
     }
     /**
      * Finds documents based on provided filters and options
@@ -188,120 +173,116 @@ class ResourcesAPIBase {
      * @param {object} field key value, key=field value: 0=exclude, 1=include
      * @returns {an Object that contains an items field}
      */
-    read(filter = {}, limit = 1000, offset = 0, sort = {}, field = {}, customQueries = [], customArgs = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const options = {
-                limit: Math.min(limit, 1000),
-                offset,
-                sort,
-                fields: field,
-                customQueries,
-                customArguments: customArgs.value ? JSON.parse(customArgs.value.toString()) : {}
-            };
-            const entities = yield this.db.find(this.collectionName, filter, options);
-            if (this.bufferField) {
-                // encode the msg obj back to buffer obj and send it back
-                entities.forEach(element => {
-                    if (element[this.bufferField]) {
-                        element = encodeMsgObj(element, this.bufferField);
-                        return element;
-                    }
-                });
-            }
-            return entities;
-        });
+    async read(filter = {}, limit = 1000, offset = 0, sort = {}, field = {}, customQueries = [], customArgs = {}) {
+        const options = {
+            limit: Math.min(limit, 1000),
+            offset,
+            sort,
+            fields: field,
+            customQueries,
+            customArguments: customArgs.value ? JSON.parse(customArgs.value.toString()) : {}
+        };
+        const entities = await this.db.find(this.collectionName, filter, options);
+        if (this.bufferField) {
+            // encode the msg obj back to buffer obj and send it back
+            entities.forEach(element => {
+                if (element[this.bufferField]) {
+                    element = encodeMsgObj(element, this.bufferField);
+                    return element;
+                }
+            });
+        }
+        return entities;
     }
     /**
     * Inserts documents to the database.
     *
     * @param {array.object} documents
     */
-    create(documents) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const collection = this.collectionName;
-            const toInsert = [];
+    async create(documents) {
+        const collection = this.collectionName;
+        const toInsert = [];
+        let result = [];
+        try {
             let result = [];
-            try {
-                let result = [];
-                // check if all the required fields are present
-                if (this.requiredFields && this.requiredFields[this.resourceName]) {
-                    const requiredFieldsResult = this.checkRequiredFields(this.requiredFields[this.resourceName], documents, result);
-                    documents = requiredFieldsResult.documents;
-                    result = requiredFieldsResult.result;
-                }
-                for (let i = 0; i < documents.length; i += 1) {
-                    documents[i] = yield setDefaults(documents[i], collection);
-                    // decode the buffer and store it to DB
-                    if (this.bufferField) {
-                        toInsert.push(decodeBufferObj(_.cloneDeep(documents[i]), this.bufferField));
-                    }
+            // check if all the required fields are present
+            if (this.requiredFields && this.requiredFields[this.resourceName]) {
+                const requiredFieldsResult = this.checkRequiredFields(this.requiredFields[this.resourceName], documents, result);
+                documents = requiredFieldsResult.documents;
+                result = requiredFieldsResult.result;
+            }
+            for (let i = 0; i < documents.length; i += 1) {
+                documents[i] = await setDefaults(documents[i], collection);
+                // decode the buffer and store it to DB
+                if (this.bufferField) {
+                    toInsert.push(decodeBufferObj(_.cloneDeep(documents[i]), this.bufferField));
                 }
-                if (this.isGraphDB(this.db)) {
-                    yield this.db.createGraphDB(this.graphName);
-                    yield this.db.addVertexCollection(collection);
-                    let createVertexResp = yield this.db.createVertex(collection, this.bufferField ? toInsert : documents);
-                    for (let document of documents) {
-                        if (this.edgeCfg && _.isArray(this.edgeCfg) && this.edgeCfg.length > 0) {
-                            for (let eachEdgeCfg of this.edgeCfg) {
-                                const fromIDkey = eachEdgeCfg.from;
-                                const from_id = document[fromIDkey];
-                                const toIDkey = eachEdgeCfg.to;
-                                const to_id = document[toIDkey];
-                                // edges are created outbound, if it is inbound - check for direction
-                                const direction = eachEdgeCfg.direction;
-                                let fromVerticeName = collection;
-                                let toVerticeName = eachEdgeCfg.toVerticeName;
-                                if (direction === 'inbound') {
-                                    fromVerticeName = eachEdgeCfg.fromVerticeName;
-                                    toVerticeName = collection;
-                                }
-                                if (from_id && to_id) {
-                                    if (_.isArray(to_id)) {
-                                        for (let toID of to_id) {
-                                            yield this.db.createEdge(eachEdgeCfg.edgeName, null, `${fromVerticeName}/${from_id}`, `${toVerticeName}/${toID}`);
-                                        }
-                                    }
-                                    else {
-                                        yield this.db.createEdge(eachEdgeCfg.edgeName, null, `${fromVerticeName}/${from_id}`, `${toVerticeName}/${to_id}`);
+            }
+            if (this.isGraphDB(this.db)) {
+                await this.db.createGraphDB(this.graphName);
+                await this.db.addVertexCollection(collection);
+                let createVertexResp = await this.db.createVertex(collection, this.bufferField ? toInsert : documents);
+                for (let document of documents) {
+                    if (this.edgeCfg && _.isArray(this.edgeCfg) && this.edgeCfg.length > 0) {
+                        for (let eachEdgeCfg of this.edgeCfg) {
+                            const fromIDkey = eachEdgeCfg.from;
+                            const from_id = document[fromIDkey];
+                            const toIDkey = eachEdgeCfg.to;
+                            const to_id = document[toIDkey];
+                            // edges are created outbound, if it is inbound - check for direction
+                            const direction = eachEdgeCfg.direction;
+                            let fromVerticeName = collection;
+                            let toVerticeName = eachEdgeCfg.toVerticeName;
+                            if (direction === 'inbound') {
+                                fromVerticeName = eachEdgeCfg.fromVerticeName;
+                                toVerticeName = collection;
+                            }
+                            if (from_id && to_id) {
+                                if (_.isArray(to_id)) {
+                                    for (let toID of to_id) {
+                                        await this.db.createEdge(eachEdgeCfg.edgeName, null, `${fromVerticeName}/${from_id}`, `${toVerticeName}/${toID}`);
                                     }
                                 }
+                                else {
+                                    await this.db.createEdge(eachEdgeCfg.edgeName, null, `${fromVerticeName}/${from_id}`, `${toVerticeName}/${to_id}`);
+                                }
                             }
                         }
                     }
-                    if (_.isArray(createVertexResp)) {
-                        for (let eachVertexResp of createVertexResp) {
-                            result.push(eachVertexResp);
-                        }
-                    }
-                    else {
-                        result.push(createVertexResp);
+                }
+                if (_.isArray(createVertexResp)) {
+                    for (let eachVertexResp of createVertexResp) {
+                        result.push(eachVertexResp);
                     }
-                    return result;
                 }
                 else {
-                    let checkReqFieldResult = [];
-                    if (!_.isEmpty(result)) {
-                        checkReqFieldResult = result;
-                    }
-                    result = yield this.db.insert(collection, this.bufferField ? toInsert : documents);
-                    if (!_.isEmpty(checkReqFieldResult)) {
-                        for (let reqFieldResult of checkReqFieldResult) {
-                            result.push(reqFieldResult);
-                        }
-                    }
-                    return result;
+                    result.push(createVertexResp);
                 }
+                return result;
             }
-            catch (e) {
-                this.logger.error('Error creating documents', { error: e.message });
-                result.push({
-                    error: true,
-                    errorNum: e.code,
-                    errorMessage: e.details ? e.details : e.message
-                });
+            else {
+                let checkReqFieldResult = [];
+                if (!_.isEmpty(result)) {
+                    checkReqFieldResult = result;
+                }
+                result = await this.db.insert(collection, this.bufferField ? toInsert : documents);
+                if (!_.isEmpty(checkReqFieldResult)) {
+                    for (let reqFieldResult of checkReqFieldResult) {
+                        result.push(reqFieldResult);
+                    }
+                }
                 return result;
             }
-        });
+        }
+        catch (e) {
+            this.logger.error('Error creating documents', { error: e.message });
+            result.push({
+                error: true,
+                errorNum: e.code,
+                errorMessage: e.details ? e.details : e.message
+            });
+            return result;
+        }
     }
     isGraphDB(db) {
         return !!this.edgeCfg;
@@ -340,114 +321,108 @@ class ResourcesAPIBase {
      *
      * @param [array.string] ids List of document IDs.
      */
-    delete(ids) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let deleteResponse = [];
-            try {
-                if (!_.isArray(ids)) {
-                    ids = [ids];
-                }
-                if (this.isGraphDB(this.db)) {
-                    // Modify the Ids to include documentHandle
-                    if (ids.length > 0) {
-                        ids = _.map(ids, (id) => {
-                            return `${this.collectionName}/${id}`;
-                        });
-                        deleteResponse = yield this.db.removeVertex(this.collectionName, ids);
-                        return deleteResponse;
-                    }
-                }
-                deleteResponse = yield this.db.delete(this.collectionName, ids);
-                return deleteResponse;
+    async delete(ids) {
+        let deleteResponse = [];
+        try {
+            if (!_.isArray(ids)) {
+                ids = [ids];
             }
-            catch (err) {
-                this.logger.error('Error deleting documents', { error: err.message });
-                deleteResponse.push({
-                    error: true,
-                    errorNum: err.code,
-                    errorMessage: err.details ? err.details : err.message
-                });
-                return deleteResponse;
+            if (this.isGraphDB(this.db)) {
+                // Modify the Ids to include documentHandle
+                if (ids.length > 0) {
+                    ids = _.map(ids, (id) => {
+                        return `${this.collectionName}/${id}`;
+                    });
+                    deleteResponse = await this.db.removeVertex(this.collectionName, ids);
+                    return deleteResponse;
+                }
             }
-        });
+            deleteResponse = await this.db.delete(this.collectionName, ids);
+            return deleteResponse;
+        }
+        catch (err) {
+            this.logger.error('Error deleting documents', { error: err.message });
+            deleteResponse.push({
+                error: true,
+                errorNum: err.code,
+                errorMessage: err.details ? err.details : err.message
+            });
+            return deleteResponse;
+        }
     }
     /**
      * Delete all documents in the collection.
      */
-    deleteCollection() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isGraphDB(this.db)) {
-                // graph edges are only deleted automatically when a specific vertex is deleted
-                // (`truncate` does not work in this case)
-                const ids = yield this.db.find(this.collectionName, {}, {
-                    fields: {
-                        id: 1
-                    }
-                });
-                yield this.delete(_.map(ids, (doc) => {
-                    return doc.id;
-                }));
-                return ids;
-            }
-            else {
-                const entities = yield this.db.find(this.collectionName, {}, { fields: { id: 1 } });
-                yield this.db.truncate(this.collectionName);
-                return entities;
-            }
-        });
+    async deleteCollection() {
+        if (this.isGraphDB(this.db)) {
+            // graph edges are only deleted automatically when a specific vertex is deleted
+            // (`truncate` does not work in this case)
+            const ids = await this.db.find(this.collectionName, {}, {
+                fields: {
+                    id: 1
+                }
+            });
+            await this.delete(_.map(ids, (doc) => {
+                return doc.id;
+            }));
+            return ids;
+        }
+        else {
+            const entities = await this.db.find(this.collectionName, {}, { fields: { id: 1 } });
+            await this.db.truncate(this.collectionName);
+            return entities;
+        }
     }
     /**
      * Upserts documents.
      *
      * @param [array.object] documents
      */
-    upsert(documents, events, resourceName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let result = [];
-            try {
-                const dispatch = []; // CRUD events to be dispatched
-                for (let i = 0; i < documents.length; i += 1) {
-                    let doc = documents[i];
-                    decodeBufferObj(doc, this.bufferField);
-                    let foundDocs;
-                    if (doc && doc.id) {
-                        foundDocs = yield this.db.find(this.collectionName, { id: doc.id }, {
-                            fields: {
-                                meta: 1
-                            }
-                        });
-                    }
-                    let eventName;
-                    if (_.isEmpty(foundDocs)) {
-                        // insert
-                        setDefaults(doc, this.collectionName);
-                        eventName = 'Created';
-                    }
-                    else {
-                        // update
-                        const dbDoc = foundDocs[0];
-                        updateMetadata(dbDoc.meta, doc);
-                        eventName = 'Modified';
-                    }
-                    dispatch.push(events.emit(`${resourceName}${eventName}`, doc));
+    async upsert(documents, events, resourceName) {
+        let result = [];
+        try {
+            const dispatch = []; // CRUD events to be dispatched
+            for (let i = 0; i < documents.length; i += 1) {
+                let doc = documents[i];
+                decodeBufferObj(doc, this.bufferField);
+                let foundDocs;
+                if (doc && doc.id) {
+                    foundDocs = await this.db.find(this.collectionName, { id: doc.id }, {
+                        fields: {
+                            meta: 1
+                        }
+                    });
                 }
-                result = yield this.db.upsert(this.collectionName, documents);
-                yield dispatch;
-                if (this.bufferField) {
-                    return _.map(result, doc => encodeMsgObj(doc, this.bufferField));
+                let eventName;
+                if (_.isEmpty(foundDocs)) {
+                    // insert
+                    setDefaults(doc, this.collectionName);
+                    eventName = 'Created';
                 }
-                return result;
+                else {
+                    // update
+                    const dbDoc = foundDocs[0];
+                    updateMetadata(dbDoc.meta, doc);
+                    eventName = 'Modified';
+                }
+                dispatch.push(events.emit(`${resourceName}${eventName}`, doc));
             }
-            catch (error) {
-                this.logger.error('Error upserting documents', { error: error.message });
-                result.push({
-                    error: true,
-                    errorNum: error.code,
-                    errorMessage: error.details ? error.details : error.message
-                });
-                return result;
+            result = await this.db.upsert(this.collectionName, documents);
+            await dispatch;
+            if (this.bufferField) {
+                return _.map(result, doc => encodeMsgObj(doc, this.bufferField));
             }
-        });
+            return result;
+        }
+        catch (error) {
+            this.logger.error('Error upserting documents', { error: error.message });
+            result.push({
+                error: true,
+                errorNum: error.code,
+                errorMessage: error.details ? error.details : error.message
+            });
+            return result;
+        }
     }
     /**
      * Finds documents by id and updates them.
@@ -455,95 +430,93 @@ class ResourcesAPIBase {
      * @param [array.object] documents
      * A list of documents or partial documents. Each document must contain an id field.
      */
-    update(documents) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let updateResponse = [];
-            try {
-                const collectionName = this.collectionName;
-                let docsWithUpMetadata = [];
-                for (let i = 0; i < documents.length; i += 1) {
-                    let doc = documents[i];
-                    if (this.bufferField) {
-                        doc = decodeBufferObj(_.cloneDeep(documents[i]), this.bufferField);
-                    }
-                    const foundDocs = yield this.db.find(collectionName, { id: doc.id });
-                    let dbDoc;
-                    if (foundDocs && foundDocs.length === 1) {
-                        dbDoc = foundDocs[0];
-                        doc = updateMetadata(dbDoc.meta, doc);
-                    }
-                    else {
-                        dbDoc = doc; // doc not existing assigning to generate error message in response
-                    }
-                    if (this.isGraphDB(this.db)) {
-                        const db = this.db;
-                        for (let eachEdgeCfg of this.edgeCfg) {
-                            const toIDkey = eachEdgeCfg.to;
-                            let modified_to_idValues = doc[toIDkey];
-                            let db_to_idValues = dbDoc[toIDkey];
-                            if (_.isArray(modified_to_idValues)) {
-                                modified_to_idValues = _.sortBy(modified_to_idValues);
-                            }
-                            if (_.isArray(db_to_idValues)) {
-                                db_to_idValues = _.sortBy(db_to_idValues);
+    async update(documents) {
+        let updateResponse = [];
+        try {
+            const collectionName = this.collectionName;
+            let docsWithUpMetadata = [];
+            for (let i = 0; i < documents.length; i += 1) {
+                let doc = documents[i];
+                if (this.bufferField) {
+                    doc = decodeBufferObj(_.cloneDeep(documents[i]), this.bufferField);
+                }
+                const foundDocs = await this.db.find(collectionName, { id: doc.id });
+                let dbDoc;
+                if (foundDocs && foundDocs.length === 1) {
+                    dbDoc = foundDocs[0];
+                    doc = updateMetadata(dbDoc.meta, doc);
+                }
+                else {
+                    dbDoc = doc; // doc not existing assigning to generate error message in response
+                }
+                if (this.isGraphDB(this.db)) {
+                    const db = this.db;
+                    for (let eachEdgeCfg of this.edgeCfg) {
+                        const toIDkey = eachEdgeCfg.to;
+                        let modified_to_idValues = doc[toIDkey];
+                        let db_to_idValues = dbDoc[toIDkey];
+                        if (_.isArray(modified_to_idValues)) {
+                            modified_to_idValues = _.sortBy(modified_to_idValues);
+                        }
+                        if (_.isArray(db_to_idValues)) {
+                            db_to_idValues = _.sortBy(db_to_idValues);
+                        }
+                        // delete and recreate only if there is a difference in references
+                        if (!_.isEqual(modified_to_idValues, db_to_idValues)) {
+                            // TODO delete and recreate the edge (since there is no way to update the edge as we dont add id to the edge as for doc)
+                            const fromIDkey = eachEdgeCfg.from;
+                            const from_id = doc[fromIDkey];
+                            let fromVerticeName = collectionName;
+                            let toVerticeName = eachEdgeCfg.toVerticeName;
+                            const direction = eachEdgeCfg.direction;
+                            if (direction === 'inbound') {
+                                fromVerticeName = eachEdgeCfg.fromVerticeName;
+                                toVerticeName = collectionName;
                             }
-                            // delete and recreate only if there is a difference in references
-                            if (!_.isEqual(modified_to_idValues, db_to_idValues)) {
-                                // TODO delete and recreate the edge (since there is no way to update the edge as we dont add id to the edge as for doc)
-                                const fromIDkey = eachEdgeCfg.from;
-                                const from_id = doc[fromIDkey];
-                                let fromVerticeName = collectionName;
-                                let toVerticeName = eachEdgeCfg.toVerticeName;
-                                const direction = eachEdgeCfg.direction;
-                                if (direction === 'inbound') {
-                                    fromVerticeName = eachEdgeCfg.fromVerticeName;
-                                    toVerticeName = collectionName;
+                            const edgeCollectionName = eachEdgeCfg.edgeName;
+                            let outgoingEdges = await db.getOutEdges(edgeCollectionName, `${collectionName}/${dbDoc.id}`);
+                            if (_.isArray(outgoingEdges.edges)) {
+                                for (let outgoingEdge of outgoingEdges.edges) {
+                                    await db.removeEdge(edgeCollectionName, outgoingEdge._id);
                                 }
-                                const edgeCollectionName = eachEdgeCfg.edgeName;
-                                let outgoingEdges = yield db.getOutEdges(edgeCollectionName, `${collectionName}/${dbDoc.id}`);
-                                if (_.isArray(outgoingEdges.edges)) {
-                                    for (let outgoingEdge of outgoingEdges.edges) {
-                                        yield db.removeEdge(edgeCollectionName, outgoingEdge._id);
-                                    }
+                            }
+                            let incomingEdges = await db.getInEdges(edgeCollectionName, `${collectionName}/${dbDoc.id}`);
+                            if (_.isArray(incomingEdges.edges)) {
+                                for (let incomingEdge of incomingEdges.edges) {
+                                    await db.removeEdge(edgeCollectionName, incomingEdge._id);
                                 }
-                                let incomingEdges = yield db.getInEdges(edgeCollectionName, `${collectionName}/${dbDoc.id}`);
-                                if (_.isArray(incomingEdges.edges)) {
-                                    for (let incomingEdge of incomingEdges.edges) {
-                                        yield db.removeEdge(edgeCollectionName, incomingEdge._id);
+                            }
+                            // Create new edges
+                            if (from_id && modified_to_idValues) {
+                                if (_.isArray(modified_to_idValues)) {
+                                    for (let toID of modified_to_idValues) {
+                                        await db.createEdge(eachEdgeCfg.edgeName, null, `${fromVerticeName}/${from_id}`, `${toVerticeName}/${toID}`);
                                     }
                                 }
-                                // Create new edges
-                                if (from_id && modified_to_idValues) {
-                                    if (_.isArray(modified_to_idValues)) {
-                                        for (let toID of modified_to_idValues) {
-                                            yield db.createEdge(eachEdgeCfg.edgeName, null, `${fromVerticeName}/${from_id}`, `${toVerticeName}/${toID}`);
-                                        }
-                                    }
-                                    else {
-                                        yield db.createEdge(edgeCollectionName, null, `${fromVerticeName}/${from_id}`, `${toVerticeName}/${modified_to_idValues}`);
-                                    }
+                                else {
+                                    await db.createEdge(edgeCollectionName, null, `${fromVerticeName}/${from_id}`, `${toVerticeName}/${modified_to_idValues}`);
                                 }
                             }
                         }
                     }
-                    docsWithUpMetadata.push(doc);
                 }
-                updateResponse = yield this.db.update(collectionName, docsWithUpMetadata);
-                if (this.bufferField) {
-                    updateResponse = _.map(updateResponse, patch => encodeMsgObj(patch, this.bufferField));
-                }
-                return updateResponse;
+                docsWithUpMetadata.push(doc);
             }
-            catch (e) {
-                this.logger.error('Error updating documents', { error: e.message });
-                updateResponse.push({
-                    error: true,
-                    errorNum: e.code,
-                    errorMessage: e.message
-                });
-                return updateResponse;
+            updateResponse = await this.db.update(collectionName, docsWithUpMetadata);
+            if (this.bufferField) {
+                updateResponse = _.map(updateResponse, patch => encodeMsgObj(patch, this.bufferField));
             }
-        });
+            return updateResponse;
+        }
+        catch (e) {
+            this.logger.error('Error updating documents', { error: e.message });
+            updateResponse.push({
+                error: true,
+                errorNum: e.code,
+                errorMessage: e.message
+            });
+            return updateResponse;
+        }
     }
 }
 exports.ResourcesAPIBase = ResourcesAPIBase;