@restorecommerce/resource-base-interface 0.1.1 → 0.2.3

package/lib/core/ResourcesAPI.js

@@ -1,21 +1,34 @@
 "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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResourcesAPIBase = void 0;
-const _ = require("lodash");
-const bluebird = require("bluebird");
+const _ = __importStar(require("lodash"));
+const bluebird_1 = __importDefault(require("bluebird"));
 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"));
+const redis = __importStar(require("redis"));
+bluebird_1.default.promisifyAll(redis.RedisClient.prototype);
 let redisClient;
 const Strategies = {
     INCREMENT: 'increment',
@@ -29,22 +42,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.hgetallAsync(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.getAsync(key);
+                        await redisClient.incrAsync(key);
                         break;
                     case Strategies.UUID:
                         o[field] = uuidGen();
@@ -53,7 +66,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.timeAsync()[0];
                         break;
                 }
             }
@@ -67,7 +80,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;
@@ -113,7 +126,7 @@ class ResourcesAPIBase {
      * @param {string} collectionName Name of database collection.
      * @param {any} fieldHandlerConf The collection's field generators configuration.
      */
-    constructor(db, collectionName, fieldHandlerConf, edgeCfg, graphName) {
+    constructor(db, collectionName, fieldHandlerConf, edgeCfg, graphName, logger) {
         this.db = db;
         this.collectionName = collectionName;
         this.edgeCfg = edgeCfg;
@@ -188,56 +201,57 @@ 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 = [];
-            try {
-                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]) {
-                    this.checkRequiredFields(this.requiredFields[this.resourceName], documents);
+    async create(documents) {
+        const collection = this.collectionName;
+        const toInsert = [];
+        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] = await setDefaults(documents[i], collection);
+                // decode the buffer and store it to DB
+                if (this.bufferField) {
+                    toInsert.push(decodeBufferObj(_.cloneDeep(documents[i]), this.bufferField));
                 }
-                let result = [];
-                if (this.isGraphDB(this.db)) {
-                    yield this.db.createGraphDB(this.graphName);
-                    yield this.db.addVertexCollection(collection);
-                    result = yield this.db.createVertex(collection, this.bufferField ? toInsert : documents);
-                    for (let document of documents) {
+            }
+            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];
@@ -251,35 +265,52 @@ class ResourcesAPIBase {
                                 fromVerticeName = eachEdgeCfg.fromVerticeName;
                                 toVerticeName = collection;
                             }
-                            if (fromVerticeName && toVerticeName) {
-                                yield this.db.addEdgeDefinition(eachEdgeCfg.edgeName, [fromVerticeName], [toVerticeName]);
-                            }
                             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}`);
+                                        await this.db.createEdge(eachEdgeCfg.edgeName, null, `${fromVerticeName}/${from_id}`, `${toVerticeName}/${toID}`);
                                     }
-                                    continue;
                                 }
-                                yield this.db.createEdge(eachEdgeCfg.edgeName, null, `${fromVerticeName}/${from_id}`, `${toVerticeName}/${to_id}`);
+                                else {
+                                    await this.db.createEdge(eachEdgeCfg.edgeName, null, `${fromVerticeName}/${from_id}`, `${toVerticeName}/${to_id}`);
+                                }
                             }
                         }
                     }
-                    result.push(result);
-                    return result;
+                }
+                if (_.isArray(createVertexResp)) {
+                    for (let eachVertexResp of createVertexResp) {
+                        result.push(eachVertexResp);
+                    }
                 }
                 else {
-                    yield this.db.insert(collection, this.bufferField ? toInsert : documents);
+                    result.push(createVertexResp);
                 }
+                return result;
             }
-            catch (e) {
-                if (e.code === 409 || (e.message &&
-                    e.message.includes('unique constraint violated'))) {
-                    throw new chassis_srv_1.errors.AlreadyExists('Item Already exists.');
+            else {
+                let checkReqFieldResult = [];
+                if (!_.isEmpty(result)) {
+                    checkReqFieldResult = result;
                 }
-                throw { code: e.code, message: e.message, details: e.details };
+                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;
@@ -289,123 +320,137 @@ class ResourcesAPIBase {
      * @param requiredFields
      * @param documents
      */
-    checkRequiredFields(requiredFields, documents) {
+    checkRequiredFields(requiredFields, documents, result) {
         for (let document of documents) {
             for (let eachField of requiredFields) {
                 const isArray = _.isArray(eachField);
                 if (!document[eachField]) {
-                    throw new chassis_srv_1.errors.InvalidArgument(`Field ${eachField} is necessary
-            for ${this.resourceName}`);
+                    result.push({
+                        error: true,
+                        errorNum: 400,
+                        errorMessage: `Field ${eachField} is necessary for ${this.resourceName} for documentID ${document.id}`
+                    });
+                    documents = documents.filter(doc => doc.id != document.id);
                 }
                 if ((isArray && document[eachField].length == 0)) {
-                    throw new chassis_srv_1.errors.InvalidArgument(`Field ${eachField} is necessary
-            for ${this.resourceName}`);
+                    result.push({
+                        error: true,
+                        errorNum: 400,
+                        errorMessage: `Field ${eachField} is necessary for ${this.resourceName} for documentID ${document.id}`
+                    });
+                    documents = documents.filter(doc => doc.id != document.id);
                 }
             }
         }
+        return { documents, result };
     }
     /**
      * Removes documents found by id.
      *
      * @param [array.string] ids List of document IDs.
      */
-    delete(ids) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const filter = {
-                id: {
-                    $in: ids
-                }
-            };
-            try {
-                if (this.isGraphDB(this.db)) {
-                    // Modify the Ids to include documentHandle
-                    if (ids.length > 0) {
-                        ids = _.map(ids, (id) => {
-                            return `${this.collectionName}/${id}`;
-                        });
-                        return yield this.db.removeVertex(this.collectionName, ids);
-                    }
-                }
-                yield this.db.delete(this.collectionName, filter);
+    async delete(ids) {
+        let deleteResponse = [];
+        try {
+            if (!_.isArray(ids)) {
+                ids = [ids];
             }
-            catch (err) {
-                if (err.code === 404 || (err.message &&
-                    err.message.includes('collection not found'))) {
-                    throw new chassis_srv_1.errors.NotFound('Collection or one or more items with the given IDs not found.');
+            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* () {
-            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);
-                    const foundDocs = yield this.db.find(this.collectionName, { id: doc.id }, {
+    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
                         }
                     });
-                    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));
                 }
-                const 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;
-            }
-            catch (error) {
-                if (error.code === 404) {
-                    throw new chassis_srv_1.errors.NotFound('Can\'t find one or more items with the given IDs.');
+                else {
+                    // update
+                    const dbDoc = foundDocs[0];
+                    updateMetadata(dbDoc.meta, doc);
+                    eventName = 'Modified';
                 }
-                throw { code: error.code, message: error.message, details: error.details };
+                dispatch.push(events.emit(`${resourceName}${eventName}`, doc));
             }
-        });
+            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.
@@ -413,87 +458,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* () {
-            try {
-                const collectionName = this.collectionName;
-                let patches = [];
-                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 }, {
-                        fields: {
-                            meta: 1
-                        }
-                    });
-                    if (_.isEmpty(foundDocs)) {
-                        throw { code: 404 };
-                    }
-                    const dbDoc = foundDocs[0];
+    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);
-                    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);
+                }
+                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 = yield db.getOutEdges(edgeCollectionName, `${collectionName}/${dbDoc.id}`);
-                                for (let outgoingEdge of outgoingEdges) {
-                                    yield db.removeEdge(edgeCollectionName, outgoingEdge._id);
+                            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);
                                 }
-                                let incomingEdges = yield db.getInEdges(edgeCollectionName, `${collectionName}/${dbDoc.id}`);
-                                for (let incomingEdge of incomingEdges) {
-                                    yield db.removeEdge(edgeCollectionName, incomingEdge._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);
                                 }
-                                // 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}`);
-                                        }
-                                        continue;
+                            }
+                            // 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}`);
                                     }
-                                    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}`);
                                 }
                             }
                         }
                     }
-                    patches.push(yield this.db.update(collectionName, { id: doc.id }, _.omitBy(doc, _.isNil)));
-                }
-                patches = _.flatten(patches);
-                if (this.bufferField) {
-                    patches = _.map(patches, patch => encodeMsgObj(patch, this.bufferField));
                 }
-                return patches;
+                docsWithUpMetadata.push(doc);
             }
-            catch (e) {
-                if (e.code === 404) {
-                    throw new chassis_srv_1.errors.NotFound('Can\'t find one or more items with the given IDs.');
-                }
-                throw { code: e.code, message: e.message, details: e.details };
+            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;