@restorecommerce/resource-base-interface 1.6.5 → 1.7.1

package/lib/core/ResourcesAPI.js

@@ -1,104 +1,31 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (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 _ = __importStar(require("lodash"));
-const chassis_srv_1 = require("@restorecommerce/chassis-srv");
-const uuid = __importStar(require("uuid"));
+const crypto_1 = require("crypto");
 const utils_1 = require("./utils");
-let redisClient;
-const Strategies = {
-    INCREMENT: 'increment',
-    UUID: 'uuid',
-    RANDOM: 'random',
-    TIMESTAMP: 'timestamp'
-};
-const uuidGen = () => {
-    return uuid.v4().replace(/-/g, '');
-};
-const isEmptyObject = (obj) => {
-    return !Object.keys(obj).length;
-};
-const setDefaults = async (obj, collectionName, subject) => {
-    const o = obj;
-    if (_.isEmpty(o.meta)) {
-        throw new chassis_srv_1.errors.InvalidArgument('Object does not contain ownership information');
-    }
-    if (redisClient) {
-        const values = await redisClient.hGetAll(collectionName);
-        if (values) {
-            for (const field in values) {
-                const strategy = values[field];
-                let key;
-                switch (strategy) {
-                    case Strategies.INCREMENT:
-                        key = collectionName + ':' + field;
-                        o[field] = await redisClient.get(key);
-                        await redisClient.incr(key);
-                        break;
-                    case Strategies.UUID:
-                        o[field] = uuidGen();
-                        break;
-                    case Strategies.RANDOM:
-                        o[field] = uuidGen();
-                        break;
-                    case Strategies.TIMESTAMP:
-                        o[field] = await redisClient.time()[0];
-                        break;
-                }
-            }
-        }
-    }
-    if (_.isNil(o.meta.created) || o.meta.created === 0) {
-        o.meta.created = new Date();
-    }
-    o.meta.created_by = subject?.id;
-    o.meta.modified_by = subject?.id;
-    o.meta.modified = new Date();
-    if (_.isNil(o.id) || o.id === 0 || isEmptyObject(o.id)) {
-        o.id = uuidGen();
-    }
-    return o;
-};
-const updateMetadata = (docMeta, newDoc, subject) => {
-    if (_.isEmpty(newDoc.meta)) {
-        throw new chassis_srv_1.errors.InvalidArgument(`Update request holds no valid metadata for document ${newDoc.id}`);
-    }
-    if (!_.isEmpty(newDoc.meta?.owners)) {
-        // if ownership is meant to be updated
-        docMeta.owners = newDoc.meta.owners;
-    }
-    docMeta.modified_by = subject?.id;
-    docMeta.modified = new Date();
-    newDoc.meta = docMeta;
-    return newDoc;
-};
+// let redisClient: any;
+var Strategies;
+(function (Strategies) {
+    Strategies["INCREMENT"] = "increment";
+    Strategies["UUID"] = "uuid";
+    Strategies["RANDOM"] = "random";
+    Strategies["TIMESTAMP"] = "timestamp";
+})(Strategies || (Strategies = {}));
+const uuidGen = () => (0, crypto_1.randomUUID)().replace(/-/g, '');
 /**
  * Resource API base provides functions for CRUD operations.
  */
 class ResourcesAPIBase {
+    db;
+    collectionName;
+    edgeCfg;
+    graphName;
+    logger;
+    resourceName;
+    bufferFields;
+    requiredFields;
+    timeStampFields;
+    redisClient;
     /**
      * @constructor
      * @param  {object} db Chassis arangodb provider.
@@ -116,29 +43,20 @@ class ResourcesAPIBase {
         if (!fieldHandlerConf) {
             return;
         }
-        const strategyCfg = fieldHandlerConf.strategies;
-        if (!redisClient) {
-            redisClient = fieldHandlerConf.redisClient;
-        }
-        if (fieldHandlerConf.bufferFields) {
-            this.bufferFields = fieldHandlerConf.bufferFields;
-        }
-        // config fix to be removed after ts-proto is used
-        if (fieldHandlerConf.timeStampFields) {
-            this.timeStampFields = fieldHandlerConf.timeStampFields;
-        }
-        if (fieldHandlerConf.requiredFields) {
-            this.requiredFields = fieldHandlerConf.requiredFields[this.resourceName] ?? fieldHandlerConf.requiredFields;
-        }
+        const strategyCfg = fieldHandlerConf?.strategies ?? [];
+        this.redisClient = fieldHandlerConf?.redisClient;
+        this.bufferFields = fieldHandlerConf?.bufferFields;
+        this.timeStampFields = fieldHandlerConf?.timeStampFields;
+        this.requiredFields = fieldHandlerConf?.requiredFields?.[this.resourceName] ?? fieldHandlerConf?.requiredFields;
         // values for Redis hash set
         for (const field in strategyCfg) {
             const strategy = strategyCfg[field].strategy;
-            redisClient.hSet(collectionName, field, strategy);
-            let startingValue;
+            this.redisClient.hSet(collectionName, field, strategy);
             switch (strategy) {
-                case Strategies.INCREMENT:
+                case Strategies.INCREMENT: {
                     // check if value already exists in redis
-                    startingValue = redisClient.get(`${collectionName}:${field}`).then((val) => val);
+                    let startingValue;
+                    startingValue = this.redisClient.get(`${collectionName}:${field}`).then((val) => val);
                     if (!startingValue) {
                         if (strategyCfg[field].startingValue) {
                             startingValue = Number.isNaN(strategyCfg[field].startingValue) ?
@@ -147,42 +65,91 @@ class ResourcesAPIBase {
                         else {
                             startingValue = '0';
                         }
-                        redisClient.set(`${collectionName}:${field}`, startingValue).then((val) => val);
+                        this.redisClient.set(`${collectionName}:${field}`, startingValue).then((val) => val);
                     }
                     break;
+                }
                 default:
                     break;
             }
         }
     }
+    catchOperationError(msg, err) {
+        this.logger?.error(msg, err);
+        return {
+            code: Number.isInteger(err.code) ? err.code : 500,
+            message: err.message ?? 'Unknown Error!',
+        };
+    }
+    catchStatusError(msg, err) {
+        this.logger?.error(msg, err);
+        return {
+            code: Number.isInteger(err.code) ? err.code : 500,
+            message: err.message ?? 'Unknown Error!',
+        };
+    }
+    setMeta(o, subject, create = false) {
+        o.meta ??= {};
+        if (create) {
+            o.meta.created ??= new Date();
+            o.meta.created_by ??= subject?.id;
+        }
+        o.meta.modified_by ??= subject?.id;
+        o.meta.modified ??= new Date();
+        if (!o.id?.length || o.id?.toString() === '0') {
+            o.id = uuidGen();
+        }
+        return o;
+    }
+    async setDefaults(o, collectionName, subject, create = false) {
+        if (create && this.redisClient) {
+            const values = await this.redisClient.hGetAll(collectionName);
+            if (values) {
+                for (const field in values) {
+                    const strategy = values[field];
+                    switch (strategy) {
+                        case Strategies.INCREMENT: {
+                            const key = `${collectionName}:${field}`;
+                            o[field] = await this.redisClient.get(key);
+                            await this.redisClient.incr(key);
+                            break;
+                        }
+                        case Strategies.TIMESTAMP:
+                            o[field] = (await this.redisClient.time()).getTime();
+                            break;
+                        default:
+                        case Strategies.UUID:
+                        case Strategies.RANDOM:
+                            o[field] = uuidGen();
+                            break;
+                    }
+                }
+            }
+        }
+        return this.setMeta(o, subject, create);
+    }
     /**
      * Finds documents based on provided filters and options
      * @param {object} filter key value filter using mongodb/nedb filter format.
      * @param {number} limit
      * @param {number} offset
      * @param {object} sort key value, key=field value: 1=ASCENDING, -1=DESCENDING, 0=UNSORTED
-     * @param {object} field key value, key=field value: 0=exclude, 1=include
+     * @param {object} fields key value, key=field value: 0=exclude, 1=include
      * @returns {an Object that contains an items field}
      */
-    async read(filter = {}, limit = 1000, offset = 0, sort = {}, field = {}, customQueries = [], customArgs = {}, search) {
+    async read(filter = {}, limit = 1000, offset = 0, sort = {}, fields = {}, customQueries = [], customArgs = {}, search) {
         const options = {
             limit: Math.min(limit, 1000),
             offset,
             sort,
-            fields: field,
+            fields,
             customQueries,
-            customArguments: customArgs.value ? JSON.parse(customArgs.value.toString()) : {},
+            customArguments: customArgs?.value ? JSON.parse(customArgs.value.toString()) : {},
             search
         };
         let entities = await this.db.find(this.collectionName, filter, options);
-        if (this.bufferFields && entities?.length > 0) {
-            // encode the msg obj back to buffer obj and send it back
-            entities = this.encodeOrDecode(entities, this.bufferFields, 'encode');
-        }
-        if (this.timeStampFields && entities?.length > 0) {
-            // convert number to Date Object
-            entities = this.encodeOrDecode(entities, this.timeStampFields, 'convertMilisecToDateObj');
-        }
+        entities = this.encodeOrDecode(entities, this.bufferFields, 'encode');
+        entities = this.encodeOrDecode(entities, this.timeStampFields, 'convertMilisecToDateObj');
         return entities;
     }
     /**
@@ -190,95 +157,68 @@ class ResourcesAPIBase {
     *
     * @param {array.object} documents
     */
-    async create(documents, subject) {
+    async create(documents, subject, events) {
         const collection = this.collectionName;
-        let result = [];
-        try {
-            // check if all the required fields are present
-            if (this.requiredFields) {
-                const requiredFieldsResult = this.checkRequiredFields(this.requiredFields, documents, result);
-                documents = requiredFieldsResult.documents;
-                result = requiredFieldsResult.result;
-            }
-            documents = await Promise.all(documents.map(async (doc) => {
-                return await setDefaults(doc, collection, subject);
-            }));
-            if (this.bufferFields && documents?.length > 0) {
-                documents = this.encodeOrDecode(documents, this.bufferFields, 'decode');
-            }
-            if (this.timeStampFields && documents?.length > 0) {
-                // convert Date Object to Number
-                documents = this.encodeOrDecode(documents, this.timeStampFields, 'convertDateObjToMilisec');
-            }
-            if (this.isGraphDB(this.db)) {
-                await this.db.createGraphDB(this.graphName, [], {});
-                await this.db.addVertexCollection(collection);
-                const createVertexResp = await this.db.createVertex(collection, documents);
-                for (const document of documents) {
-                    if (this.edgeCfg && Array.isArray(this.edgeCfg) && this.edgeCfg.length > 0) {
-                        for (const 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 (Array.isArray(to_id)) {
-                                    for (const 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}`);
-                                }
+        const result = new Array();
+        // check if all the required fields are present
+        if (this.requiredFields) {
+            documents = this.checkRequiredFields(this.requiredFields, documents, result);
+        }
+        documents = await Promise.all(documents.map(async (doc) => await this.setDefaults(doc, collection, subject, true)));
+        documents = this.encodeOrDecode(documents, this.bufferFields, 'decode');
+        documents = this.encodeOrDecode(documents, this.timeStampFields, 'convertDateObjToMilisec');
+        if (this.isGraphDB(this.db)) {
+            const db = this.db;
+            await db.addVertexCollection(collection);
+            const createVertexResp = await this.db.createVertex(collection, documents);
+            await Promise.all(documents.map(async (document) => {
+                try {
+                    for (const 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 inbound = eachEdgeCfg.direction === 'inbound';
+                        const fromVerticeName = inbound ? eachEdgeCfg.fromVerticeName : collection;
+                        const toVerticeName = inbound ? collection : eachEdgeCfg.toVerticeName;
+                        const ids = Array.isArray(to_id) ? to_id : [to_id];
+                        if (from_id && to_id) {
+                            for (const id of ids) {
+                                await db.createEdge(eachEdgeCfg.edgeName, null, `${fromVerticeName}/${from_id}`, `${toVerticeName}/${id}`);
                             }
                         }
                     }
                 }
-                if (Array.isArray(createVertexResp)) {
-                    createVertexResp.forEach((eachVertexResp) => result.push(eachVertexResp));
-                }
-                else {
-                    result.push(createVertexResp);
-                }
-                if (this.timeStampFields && result?.length > 0) {
-                    // convert number to Date Object
-                    result = this.encodeOrDecode(result, this.timeStampFields, 'convertMilisecToDateObj');
+                catch (error) {
+                    result.push({
+                        error: true,
+                        errorNum: error?.code,
+                        errorMessage: error?.details ?? error?.message
+                    });
                 }
-                return result;
+            }));
+            if (Array.isArray(createVertexResp)) {
+                result.push(...createVertexResp);
             }
             else {
-                let checkReqFieldResult = [];
-                if (!_.isEmpty(result)) {
-                    checkReqFieldResult = result;
-                }
-                result = await this.db.insert(collection, documents);
-                if (!_.isEmpty(checkReqFieldResult)) {
-                    checkReqFieldResult.forEach((reqFieldResult) => result.push(reqFieldResult));
-                }
-                if (this.timeStampFields && result?.length > 0) {
-                    // convert number to Date Object
-                    result = this.encodeOrDecode(result, this.timeStampFields, 'convertMilisecToDateObj');
-                }
-                return result;
+                result.push(createVertexResp);
             }
+            this.encodeOrDecode(result, this.timeStampFields, 'convertMilisecToDateObj');
         }
-        catch (error) {
-            this.logger?.error('Error creating documents', { code: error?.code, message: error?.message, stack: error?.stack });
-            result.push({
-                error: true,
-                errorNum: error?.code,
-                errorMessage: error?.details ? error?.details : error?.message
-            });
-            return result;
+        else {
+            const inserts = await this.db.insert(collection, documents);
+            result.push(...inserts);
+            this.encodeOrDecode(result, this.timeStampFields, 'convertMilisecToDateObj');
         }
+        if (events) {
+            await Promise.all(result?.map(async (item) => {
+                if (!item?.error) {
+                    await events.emit(`${this.resourceName}Created`, item);
+                }
+            }));
+        }
+        return result;
     }
     isGraphDB(db) {
         return !!this.edgeCfg;
@@ -288,77 +228,64 @@ class ResourcesAPIBase {
      * @param requiredFields
      * @param documents
      */
-    checkRequiredFields(requiredFields, documents, result) {
-        documents = documents.filter((document) => {
-            return requiredFields.every((eachField) => {
-                if (document[eachField] === undefined || (Array.isArray(document[eachField]) && document[eachField].length === 0)) {
-                    result.push({
+    checkRequiredFields(requiredFields, documents, errors) {
+        const valid = documents.filter((document) => {
+            return requiredFields.every((field) => {
+                if (document[field] === undefined || (Array.isArray(document[field]) && document[field].length === 0)) {
+                    errors.push({
+                        id: document.id,
                         error: true,
                         errorNum: 400,
-                        errorMessage: `Field ${eachField} is necessary for ${this.resourceName} for documentID ${document.id}`
+                        errorMessage: `Field ${field} is necessary for ${this.resourceName} in document ${document.id}`
                     });
                     return false;
                 }
                 return true;
             });
         });
-        return { documents, result };
+        return valid;
     }
     /**
      * Removes documents found by id.
      *
      * @param [array.string] ids List of document IDs.
      */
-    async delete(ids) {
-        let deleteResponse = [];
-        try {
-            if (!Array.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 = await this.db.removeVertex(this.collectionName, ids);
-                    return deleteResponse;
-                }
+    async delete(ids, events) {
+        let response;
+        if (!Array.isArray(ids)) {
+            ids = [ids];
+        }
+        if (this.isGraphDB(this.db)) {
+            // Modify the Ids to include documentHandle
+            if (ids.length > 0) {
+                ids = ids?.map((id) => `${this.collectionName}/${id}`);
+                response = await this.db.removeVertex(this.collectionName, ids);
             }
-            deleteResponse = await this.db.delete(this.collectionName, ids);
-            return deleteResponse;
         }
-        catch (error) {
-            this.logger?.error('Error deleting documents', { code: error?.code, message: error?.message, stack: error?.stack });
-            deleteResponse.push({
-                error: true,
-                errorNum: error?.code,
-                errorMessage: error?.details ? error?.details : error?.message
-            });
-            return deleteResponse;
+        else {
+            response = await this.db.delete(this.collectionName, ids);
+        }
+        if (events) {
+            await Promise.all(response?.map(async (id) => {
+                if (id && !id?.error) {
+                    await events?.emit(`${this.resourceName}Deleted`, typeof id === 'string' ? { id } : id);
+                }
+            }));
         }
+        return response;
     }
     /**
      * Delete all documents in the collection.
      */
-    async deleteCollection() {
+    async deleteCollection(events) {
+        await this.db.truncate(this.collectionName);
         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;
+            const db = this.db;
+            const edges = await db.getGraphDB().get().then((info) => info.edgeDefinitions);
+            await Promise.all(edges?.filter(edge => Object.values(edge).flatMap(edge => edge).includes(this.collectionName)).map(edge => db.truncate(edge.collection)) ?? []);
         }
-        else {
-            const entities = await this.db.find(this.collectionName, {}, { fields: { id: 1 } });
-            await this.db.truncate(this.collectionName);
-            return entities;
+        if (events) {
+            await events?.emit(`${this.resourceName}DeletedAll`, { collection: this.collectionName });
         }
     }
     /**
@@ -366,73 +293,39 @@ class ResourcesAPIBase {
      *
      * @param [array.object] documents
      */
-    async upsert(documents, events, resourceName, subject) {
-        let result = [];
-        let createDocsResult = [];
-        let updateDocsResult = [];
-        try {
-            const createDocuments = [];
-            const updateDocuments = [];
-            if (this.bufferFields && documents) {
-                documents = this.encodeOrDecode(documents, this.bufferFields, 'decode');
-            }
-            const dispatch = await Promise.all(documents.map(async (doc) => {
-                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, subject);
-                    createDocuments.push(doc);
-                    eventName = 'Created';
-                }
-                else {
-                    // convert dateTimeStamp fields
-                    if (this.timeStampFields) {
-                        foundDocs = this.encodeOrDecode(foundDocs, this.timeStampFields, 'convertMilisecToDateObj');
-                    }
-                    // update
-                    const dbDoc = foundDocs[0];
-                    updateMetadata(dbDoc.meta, doc, subject);
-                    updateDocuments.push(doc);
-                    eventName = 'Modified';
-                }
-                if (events) {
-                    return events.emit(`${resourceName}${eventName}`, doc);
-                }
-            }));
-            if (createDocuments?.length > 0) {
-                createDocsResult = await this.create(createDocuments, subject);
+    async upsert(documents, subject, events) {
+        const createDocuments = new Array();
+        const updateDocuments = new Array();
+        documents = this.encodeOrDecode(documents, this.bufferFields, 'decode');
+        const orgs = new Set(await this.db.find(this.collectionName, {
+            _key: {
+                $in: [...new Set(documents?.map(doc => doc.id).filter(id => id))],
+            },
+        }, {
+            fields: {
+                id: 1
             }
-            if (updateDocuments?.length > 0) {
-                updateDocsResult = await this.update(updateDocuments, subject);
+        }).then(resp => resp.map(doc => doc.id)));
+        documents?.forEach((doc) => {
+            if (orgs.has(doc?.id)) {
+                // update
+                updateDocuments.push(doc);
             }
-            result = _.union(createDocuments, updateDocuments);
-            if (this.timeStampFields && result?.length > 0) {
-                // convert number to Date Object
-                result = this.encodeOrDecode(result, this.timeStampFields, 'convertMilisecToDateObj');
-            }
-            await Promise.all(dispatch);
-            if (this.bufferFields && result?.length > 0) {
-                result = this.encodeOrDecode(result, this.bufferFields, 'encode');
+            else {
+                // insert
+                createDocuments.push(doc);
             }
-            return result;
+        });
+        if (updateDocuments?.length > 0) {
+            await this.update(updateDocuments, subject, events);
         }
-        catch (error) {
-            this.logger?.error('Error upserting documents', { code: error?.code, message: error?.message, stack: error?.stack });
-            result.push({
-                error: true,
-                errorNum: error?.code,
-                errorMessage: error?.details ? error?.details : error?.message
-            });
-            return result;
+        if (createDocuments?.length > 0) {
+            await this.create(createDocuments, subject, events);
         }
+        const result = [...updateDocuments, ...createDocuments];
+        this.encodeOrDecode(result, this.timeStampFields, 'convertMilisecToDateObj');
+        this.encodeOrDecode(result, this.bufferFields, 'encode');
+        return result;
     }
     /**
      * Finds documents by id and updates them.
@@ -440,96 +333,85 @@ class ResourcesAPIBase {
      * @param [array.object] documents
      * A list of documents or partial documents. Each document must contain an id field.
      */
-    async update(documents, subject) {
-        let updateResponse = [];
-        try {
-            const collectionName = this.collectionName;
-            if (this.bufferFields && documents) {
-                documents = this.encodeOrDecode(documents, this.bufferFields, 'decode');
-            }
-            let docsWithUpMetadata = await Promise.all(documents.map(async (doc) => {
-                const foundDocs = await this.db.find(collectionName, { id: doc.id }, { limit: 1 });
-                let dbDoc;
-                if (foundDocs && foundDocs.length === 1) {
-                    dbDoc = foundDocs[0];
-                    doc = updateMetadata(dbDoc.meta, doc, subject);
-                }
-                else {
-                    dbDoc = doc; // doc not existing assigning to generate error message in response
-                }
+    async update(documents, subject, events) {
+        documents = this.encodeOrDecode(documents, this.bufferFields, 'decode');
+        documents = documents.map((doc) => this.setMeta(doc, subject));
+        documents = await Promise.all(documents.map(async (doc) => {
+            try {
                 if (this.isGraphDB(this.db)) {
                     const db = this.db;
-                    await Promise.all(this.edgeCfg.map(async (eachEdgeCfg) => {
-                        const toIDkey = eachEdgeCfg.to;
-                        let modified_to_idValues = doc[toIDkey];
-                        let db_to_idValues = dbDoc[toIDkey];
-                        if (Array.isArray(modified_to_idValues)) {
-                            modified_to_idValues = _.sortBy(modified_to_idValues);
-                        }
-                        if (Array.isArray(db_to_idValues)) {
-                            db_to_idValues = _.sortBy(db_to_idValues);
-                        }
+                    await Promise.all(this.edgeCfg.map(async (edgeCfg) => {
+                        const to_id = doc[edgeCfg.to];
+                        const from_id = doc[edgeCfg.from];
+                        const edgeCollectionName = edgeCfg.edgeName;
                         // delete and recreate only if there is a difference in references
-                        if (!_.isEqual(modified_to_idValues, db_to_idValues)) {
-                            // 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;
-                            const outgoingEdges = await db.getOutEdges(edgeCollectionName, `${collectionName}/${dbDoc.id}`);
-                            if (Array.isArray(outgoingEdges.edges)) {
-                                await Promise.all(outgoingEdges.edges.map((outgoingEdge) => db.removeEdge(edgeCollectionName, outgoingEdge._id)));
-                            }
-                            const incomingEdges = await db.getInEdges(edgeCollectionName, `${collectionName}/${dbDoc.id}`);
-                            if (Array.isArray(incomingEdges.edges)) {
-                                await Promise.all(incomingEdges.edges.map((incomingEdge) => db.removeEdge(edgeCollectionName, incomingEdge._id)));
+                        if (edgeCfg.direction === 'inbound' && from_id) {
+                            const from_ids = Array.isArray(from_id) ? from_id : [from_id];
+                            // if (!from_ids?.length) return;
+                            if (typeof to_id !== 'string')
+                                throw Error('Inbound value `to` has to be a single string!');
+                            const fromVerticeName = edgeCfg.fromVerticeName;
+                            const toVerticeName = edgeCfg.toVerticeName ?? this.collectionName;
+                            const incoming = await db.getInEdges(edgeCollectionName, `${fromVerticeName}/${to_id}`);
+                            // Remove edges that are no longer defined
+                            if (Array.isArray(incoming.edges)) {
+                                await Promise.all(incoming.edges?.filter((edge) => !from_ids.includes(edge._from)).map((edge) => db.removeEdge(edgeCollectionName, edge._id)));
                             }
                             // Create new edges
-                            if (from_id && modified_to_idValues) {
-                                if (Array.isArray(modified_to_idValues)) {
-                                    await Promise.all(modified_to_idValues.map((toID) => db.createEdge(eachEdgeCfg.edgeName, null, `${fromVerticeName}/${from_id}`, `${toVerticeName}/${toID}`)));
-                                }
-                                else {
-                                    await db.createEdge(edgeCollectionName, null, `${fromVerticeName}/${from_id}`, `${toVerticeName}/${modified_to_idValues}`);
-                                }
+                            await Promise.all(from_ids.filter(id => !incoming.edges?.includes(id)).map(id => db.createEdge(edgeCfg.edgeName, null, `${fromVerticeName}/${from_id}`, `${toVerticeName}/${id}`)));
+                        }
+                        else if (to_id) {
+                            const to_ids = Array.isArray(to_id) ? to_id : [to_id];
+                            // if (!to_ids?.length) return;
+                            if (typeof from_id !== 'string')
+                                throw Error('Outbound value `from` has to be a single string!');
+                            const fromVerticeName = edgeCfg.fromVerticeName ?? this.collectionName;
+                            const toVerticeName = edgeCfg.toVerticeName;
+                            const outgoing = await db.getOutEdges(edgeCollectionName, `${fromVerticeName}/${from_id}`);
+                            // Remove edges that are no longer defined
+                            if (Array.isArray(outgoing.edges)) {
+                                await Promise.all(outgoing.edges?.filter((edge) => !to_ids.includes(edge._to)).map((edge) => db.removeEdge(edgeCollectionName, edge._id)));
                             }
+                            // Create new edges
+                            await Promise.all(to_ids.filter(id => !outgoing.edges?.includes(id)).map(id => db.createEdge(edgeCfg.edgeName, null, `${fromVerticeName}/${from_id}`, `${toVerticeName}/${id}`)));
                         }
                     }));
                 }
                 return doc;
-            }));
-            if (this.timeStampFields && docsWithUpMetadata?.length > 0) {
-                docsWithUpMetadata = this.encodeOrDecode(docsWithUpMetadata, this.timeStampFields, 'convertDateObjToMilisec');
             }
-            updateResponse = await this.db.update(collectionName, docsWithUpMetadata);
-            if (this.timeStampFields && updateResponse?.length > 0) {
-                updateResponse = this.encodeOrDecode(updateResponse, this.timeStampFields, 'convertMilisecToDateObj');
+            catch (error) {
+                this.logger?.error(`Error updating document ${doc.id}`, { ...error });
+                return {
+                    ...doc,
+                    error: true,
+                    errorNum: error?.code,
+                    errorMessage: `On graph update: ${error?.details ?? error?.message}`
+                };
             }
-            if (this.bufferFields && updateResponse?.length > 0) {
-                updateResponse = this.encodeOrDecode(updateResponse, this.bufferFields, 'encode');
-            }
-            return updateResponse;
-        }
-        catch (error) {
-            this.logger?.error('Error updating documents', { code: error?.code, message: error?.message, stack: error?.stack });
-            updateResponse.push({
-                error: true,
-                errorNum: error?.code,
-                errorMessage: error?.message
-            });
-            return updateResponse;
+        }));
+        const errors = documents.filter(doc => doc.error);
+        const updates = documents.filter(doc => !doc.error);
+        this.encodeOrDecode(updates, this.timeStampFields, 'convertDateObjToMilisec');
+        const results = await this.db.update(this.collectionName, updates);
+        results.push(...errors);
+        this.encodeOrDecode(results, this.timeStampFields, 'convertMilisecToDateObj');
+        if (events) {
+            await Promise.all(results?.map(async (item) => {
+                if (!item.error) {
+                    await events.emit(`${this.resourceName}Modified`, item);
+                }
+            }));
         }
+        this.encodeOrDecode(results, this.bufferFields, 'encode');
+        return results;
     }
-    encodeOrDecode(documents, fieldPaths, fieldHanlder) {
-        for (let doc of documents) {
-            for (const fieldPath of fieldPaths) {
-                doc = (0, utils_1.fieldHandler)(doc, fieldPath, fieldHanlder);
+    encodeOrDecode(documents, fieldPaths, mode) {
+        const arr = Array.isArray(documents) ? documents : [documents];
+        if (fieldPaths?.length && arr?.length) {
+            for (const doc of arr) {
+                for (const fieldPath of fieldPaths) {
+                    (0, utils_1.fieldHandler)(doc, fieldPath, mode);
+                }
             }
         }
         return documents;