@restorecommerce/chassis-srv 0.3.3 → 0.3.7

package/lib/database/provider/arango/graph.js

@@ -1,22 +1,35 @@
 "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.ArangoGraph = void 0;
-const _ = require("lodash");
+const _ = __importStar(require("lodash"));
 const base_1 = require("./base");
 const common_1 = require("./common");
+const utils_1 = require("./utils");
+const interface_1 = require("./interface");
 class ArangoGraph extends base_1.Arango {
-    constructor(conn, graph) {
+    constructor(conn, graph, edgeDefConfig) {
         super(conn);
         this.graph = graph;
+        this.edgeDefConfig = edgeDefConfig; // edge definition config
     }
     /**
    * create a Graph instance.
@@ -26,29 +39,27 @@ class ArangoGraph extends base_1.Arango {
    * @param options — Options for creating the graph.
    * @return  {Object} A Graph instance
    */
-    createGraphDB(graphName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.graph) {
-                let graph;
-                if (_.isNil(graphName)) {
-                    throw new Error('missing graph name');
-                }
-                graph = this.db.graph(graphName);
-                try {
-                    yield graph.create();
-                }
-                catch (err) {
-                    if (err.message === 'graph already exists') {
-                        return this.graph;
-                    }
-                    throw { code: err.code, message: err.message };
-                }
-                return graph;
+    async createGraphDB(graphName) {
+        if (!this.graph) {
+            let graph;
+            if (_.isNil(graphName)) {
+                throw new Error('missing graph name');
             }
-            else {
-                return this.graph;
+            graph = this.db.graph(graphName);
+            try {
+                await graph.create();
             }
-        });
+            catch (err) {
+                if (err.message === 'graph already exists') {
+                    return this.graph;
+                }
+                throw { code: err.code, message: err.message };
+            }
+            return graph;
+        }
+        else {
+            return this.graph;
+        }
     }
     /**
      * create a new Vertex with given data.
@@ -57,41 +68,39 @@ class ArangoGraph extends base_1.Arango {
      * @param  {Object} data data for vertex
      * @return  {Object} created vertex
      */
-    createVertex(collectionName, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collectionName)) {
-                throw new Error('missing vertex collection name');
-            }
-            if (_.isNil(data)) {
-                throw new Error('missing data for vertex');
-            }
-            const collection = this.graph.vertexCollection(collectionName);
-            let docs = _.cloneDeep(data);
-            if (!_.isArray(docs)) {
-                docs = [docs];
-            }
-            _.forEach(docs, (document, i) => {
-                docs[i] = common_1.sanitizeInputFields(document);
-            });
-            let responseDocs = [];
-            for (let eachDoc of docs) {
-                let result;
-                try {
-                    result = yield collection.save(eachDoc);
-                    if (!result.error) {
-                        responseDocs.push(eachDoc);
-                    }
-                }
-                catch (e) {
-                    responseDocs.push({
-                        error: true,
-                        errorNum: e.code,
-                        errorMessage: e.message
-                    });
+    async createVertex(collectionName, data) {
+        if (_.isNil(collectionName)) {
+            throw new Error('missing vertex collection name');
+        }
+        if (_.isNil(data)) {
+            throw new Error('missing data for vertex');
+        }
+        const collection = this.graph.vertexCollection(collectionName);
+        let docs = _.cloneDeep(data);
+        if (!_.isArray(docs)) {
+            docs = [docs];
+        }
+        _.forEach(docs, (document, i) => {
+            docs[i] = (0, common_1.sanitizeInputFields)(document);
+        });
+        let responseDocs = [];
+        for (let eachDoc of docs) {
+            let result;
+            try {
+                result = await collection.save(eachDoc);
+                if (!result.error) {
+                    responseDocs.push(eachDoc);
                 }
             }
-            return _.map(responseDocs, common_1.sanitizeOutputFields);
-        });
+            catch (e) {
+                responseDocs.push({
+                    error: true,
+                    errorNum: e.code,
+                    errorMessage: e.message
+                });
+            }
+        }
+        return _.map(responseDocs, common_1.sanitizeOutputFields);
     }
     /**
      * Retreives the vertex with the given documentHandle from the collection.
@@ -102,18 +111,16 @@ class ArangoGraph extends base_1.Arango {
      * or a vertex (i.e. an object with an _id or _key property).
      * @return  {Object} created vertex
      */
-    getVertex(collectionName, documentHandle) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collectionName)) {
-                throw new Error('missing vertex collection name');
-            }
-            if (_.isNil(documentHandle)) {
-                throw new Error('missing document handle');
-            }
-            const collection = this.graph.vertexCollection(collectionName);
-            const doc = yield collection.vertex(documentHandle);
-            return doc;
-        });
+    async getVertex(collectionName, documentHandle) {
+        if (_.isNil(collectionName)) {
+            throw new Error('missing vertex collection name');
+        }
+        if (_.isNil(documentHandle)) {
+            throw new Error('missing document handle');
+        }
+        const collection = this.graph.vertexCollection(collectionName);
+        const doc = await collection.vertex(documentHandle);
+        return doc;
     }
     /**
      * Deletes the vertex with the given documentHandle from the collection.
@@ -124,28 +131,26 @@ class ArangoGraph extends base_1.Arango {
      * or a vertex (i.e. an object with an _id or _key property).
      * @return  {Object} removed vertex
      */
-    removeVertex(collectionName, documentHandles) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collectionName)) {
-                throw new Error('missing vertex collection name');
-            }
-            if (_.isNil(documentHandles)) {
-                throw new Error('missing document handle property');
-            }
-            if (!_.isArray(documentHandles)) {
-                documentHandles = [documentHandles];
-            }
-            const collection = this.graph.vertexCollection(collectionName);
-            let removedVertexList = [];
-            for (let documentHandle of documentHandles) {
-                const id = documentHandle.split('/')[1];
-                let removed = yield collection.remove(documentHandle);
-                if (!removed.error) {
-                    removedVertexList.push({ _id: documentHandle, _key: id, _rev: id });
-                }
+    async removeVertex(collectionName, documentHandles) {
+        if (_.isNil(collectionName)) {
+            throw new Error('missing vertex collection name');
+        }
+        if (_.isNil(documentHandles)) {
+            throw new Error('missing document handle property');
+        }
+        if (!_.isArray(documentHandles)) {
+            documentHandles = [documentHandles];
+        }
+        const collection = this.graph.vertexCollection(collectionName);
+        let removedVertexList = [];
+        for (let documentHandle of documentHandles) {
+            const id = documentHandle.split('/')[1];
+            let removed = await collection.remove(documentHandle);
+            if (!removed.error) {
+                removedVertexList.push({ _id: documentHandle, _key: id, _rev: id });
             }
-            return removedVertexList;
-        });
+        }
+        return removedVertexList;
     }
     /**
      * gets a new GraphVertexCollection instance with the given name for this graph.
@@ -155,14 +160,12 @@ class ArangoGraph extends base_1.Arango {
      * or a vertex (i.e. an object with an _id or _key property).
      * @return  {Object} created vertex
      */
-    getVertexCollection(collectionName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collectionName)) {
-                throw new Error('missing vertex collection name');
-            }
-            const collection = yield this.graph.vertexCollection(collectionName);
-            return collection;
-        });
+    async getVertexCollection(collectionName) {
+        if (_.isNil(collectionName)) {
+            throw new Error('missing vertex collection name');
+        }
+        const collection = await this.graph.vertexCollection(collectionName);
+        return collection;
     }
     /**
      * Fetches all vertex collections from the graph and returns
@@ -170,11 +173,9 @@ class ArangoGraph extends base_1.Arango {
      *
      * @return  {Array<Object>} vertex list
      */
-    listVertexCollections() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const collections = yield this.graph.listVertexCollections();
-            return collections;
-        });
+    async listVertexCollections() {
+        const collections = await this.graph.listVertexCollections();
+        return collections;
     }
     /**
      * Fetches all vertex collections from the database and returns an array
@@ -182,11 +183,9 @@ class ArangoGraph extends base_1.Arango {
      *
      * @return  {Array<Object>} vertex list
      */
-    getAllVertexCollections() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const collections = yield this.graph.vertexCollections();
-            return collections;
-        });
+    async getAllVertexCollections() {
+        const collections = await this.graph.vertexCollections();
+        return collections;
     }
     /**
      * Adds the collection with the given collectionName to the graph's
@@ -196,23 +195,21 @@ class ArangoGraph extends base_1.Arango {
      * @param  {boolean} excludeOrphans Whether orphan collections should be excluded.
      * @return  {Array<Object>} vertex list
      */
-    addVertexCollection(collectionName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collectionName)) {
-                throw new Error('missing vertex collection name');
-            }
-            let collection;
-            try {
-                collection = yield this.graph.addVertexCollection(collectionName);
-            }
-            catch (err) {
-                if (err.message.indexOf('collection already used in edge def') > -1 || err.message.indexOf('collection used in orphans') > -1) {
-                    return collection;
-                }
-                throw new Error(err.message);
+    async addVertexCollection(collectionName) {
+        if (_.isNil(collectionName)) {
+            throw new Error('missing vertex collection name');
+        }
+        let collection;
+        try {
+            collection = await this.graph.addVertexCollection(collectionName);
+        }
+        catch (err) {
+            if (err.message.indexOf('collection already used in edge def') > -1 || err.message.indexOf('collection used in orphans') > -1) {
+                return collection;
             }
-            return collection;
-        });
+            throw new Error(err.message);
+        }
+        return collection;
     }
     /**
      * Removes the vertex collection with the given collectionName from the graph.
@@ -222,17 +219,15 @@ class ArangoGraph extends base_1.Arango {
      * also be deleted from the database.
      * @return  {Object } removed vertex
      */
-    removeVertexCollection(collectionName, dropCollection) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collectionName)) {
-                throw new Error('missing vertex collection name');
-            }
-            if (_.isNil(dropCollection)) {
-                dropCollection = false;
-            }
-            const collection = yield this.graph.removeVertexCollection(collectionName, dropCollection);
-            return collection;
-        });
+    async removeVertexCollection(collectionName, dropCollection) {
+        if (_.isNil(collectionName)) {
+            throw new Error('missing vertex collection name');
+        }
+        if (_.isNil(dropCollection)) {
+            dropCollection = false;
+        }
+        const collection = await this.graph.removeVertexCollection(collectionName, dropCollection);
+        return collection;
     }
     /**
      * @return  {Graph} A Graph instance
@@ -254,23 +249,21 @@ class ArangoGraph extends base_1.Arango {
      * edge in the collection, or a document (i.e. an object with an _id or _key property).
      * @return  {Object} edge object
      */
-    createEdge(collectionName, data, fromId, toId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collectionName)) {
-                throw new Error('missing edge collection name');
-            }
-            if (_.isNil(data)) {
-                data = {};
-            }
-            const collection = this.graph.edgeCollection(collectionName);
-            if (fromId) {
-                Object.assign(data, { _from: fromId });
-            }
-            if (toId) {
-                Object.assign(data, { _to: toId });
-            }
-            return collection.save(data);
-        });
+    async createEdge(collectionName, data, fromId, toId) {
+        if (_.isNil(collectionName)) {
+            throw new Error('missing edge collection name');
+        }
+        if (_.isNil(data)) {
+            data = {};
+        }
+        const collection = this.graph.edgeCollection(collectionName);
+        if (fromId) {
+            Object.assign(data, { _from: fromId });
+        }
+        if (toId) {
+            Object.assign(data, { _to: toId });
+        }
+        return collection.save(data);
     }
     /**
      * Retrieves the edge with the given documentHandle from the collection.
@@ -279,17 +272,15 @@ class ArangoGraph extends base_1.Arango {
      * @param  {String} documentHandle edge key
      * @return  {Object} edge object
      */
-    getEdge(collectionName, documentHandle) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collectionName)) {
-                throw new Error('missing edge collection name');
-            }
-            if (_.isNil(documentHandle)) {
-                throw new Error('missing docuemnt handle');
-            }
-            const collection = this.graph.edgeCollection(collectionName);
-            return collection.edge(documentHandle);
-        });
+    async getEdge(collectionName, documentHandle) {
+        if (_.isNil(collectionName)) {
+            throw new Error('missing edge collection name');
+        }
+        if (_.isNil(documentHandle)) {
+            throw new Error('missing docuemnt handle');
+        }
+        const collection = this.graph.edgeCollection(collectionName);
+        return collection.edge(documentHandle);
     }
     /**
     * Retrieves a list of all edges of the document with the given documentHandle.
@@ -301,17 +292,15 @@ class ArangoGraph extends base_1.Arango {
     * (i.e. an object with an _id or _key property).
     * @return  {Object} edge object
     */
-    getAllEdgesForVertice(collectionName, documentHandle) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collectionName)) {
-                throw new Error('missing edge collection name');
-            }
-            if (_.isNil(documentHandle)) {
-                throw new Error('missing document handle');
-            }
-            const collection = this.graph.edgeCollection(collectionName).collection;
-            return yield collection.edges(documentHandle);
-        });
+    async getAllEdgesForVertice(collectionName, documentHandle) {
+        if (_.isNil(collectionName)) {
+            throw new Error('missing edge collection name');
+        }
+        if (_.isNil(documentHandle)) {
+            throw new Error('missing document handle');
+        }
+        const collection = this.graph.edgeCollection(collectionName).collection;
+        return await collection.edges(documentHandle);
     }
     /**
     * get all incoming edges.
@@ -320,17 +309,15 @@ class ArangoGraph extends base_1.Arango {
     * @param  {String} documentHandle The handle of the document
     * @return  {[Object]} list of edges
     */
-    getInEdges(collectionName, documentHandle) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collectionName)) {
-                throw new Error('missing edge name');
-            }
-            if (_.isNil(documentHandle)) {
-                throw new Error('missing document handle');
-            }
-            const collection = this.graph.edgeCollection(collectionName).collection;
-            return yield collection.inEdges(documentHandle);
-        });
+    async getInEdges(collectionName, documentHandle) {
+        if (_.isNil(collectionName)) {
+            throw new Error('missing edge name');
+        }
+        if (_.isNil(documentHandle)) {
+            throw new Error('missing document handle');
+        }
+        const collection = this.graph.edgeCollection(collectionName).collection;
+        return await collection.inEdges(documentHandle);
     }
     /**
     * get all outgoing edges.
@@ -339,62 +326,15 @@ class ArangoGraph extends base_1.Arango {
     * @param  {String} documentHandle The handle of the document
     * @return  {[Object]} list of edges
     */
-    getOutEdges(collectionName, documentHandle) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collectionName)) {
-                throw new Error('missing edge collection name');
-            }
-            if (_.isNil(documentHandle)) {
-                throw new Error('missing document handle');
-            }
-            const collection = this.graph.edgeCollection(collectionName).collection;
-            return collection.outEdges(documentHandle);
-        });
-    }
-    traversalFilter(filterObj) {
-        let stringFilter;
-        // there could be multiple vertices
-        let condition = '';
-        for (let i = 0; i < filterObj.length; i++) {
-            // check if its last element in array
-            if (i === (filterObj.length - 1)) {
-                condition = condition + ` (vertex._id.indexOf("${filterObj[i].vertex}") > -1)`;
-            }
-            else {
-                condition = condition + ` (vertex._id.indexOf("${filterObj[i].vertex}") > -1)  ||`;
-            }
+    async getOutEdges(collectionName, documentHandle) {
+        if (_.isNil(collectionName)) {
+            throw new Error('missing edge collection name');
         }
-        stringFilter = `if (${condition}) { return \"exclude\";} return;`;
-        return stringFilter;
-    }
-    traversalExpander(expanderObj) {
-        let expanderFilter;
-        // there could be multiple edges
-        let condition = '';
-        let directionVar;
-        for (let i = 0; i < expanderObj.length; i++) {
-            // check if its last element in array
-            if (i === (expanderObj.length - 1)) {
-                condition = condition + ` (e._id.indexOf("${expanderObj[i].edge}") > -1)`;
-            }
-            else {
-                condition = condition + ` (e._id.indexOf("${expanderObj[i].edge}") > -1)  ||`;
-            }
-        }
-        if ((expanderObj[0].direction).toLowerCase() == 'inbound') {
-            directionVar = 'getInEdges(vertex)';
+        if (_.isNil(documentHandle)) {
+            throw new Error('missing document handle');
         }
-        else {
-            directionVar = 'getOutEdges(vertex)';
-        }
-        expanderFilter = `var connections = [];
-    config.datasource.${directionVar}.forEach(function (e) {
-      if( ${condition} ) {
-        connections.push({ vertex: require(\"internal\").db._document(e._to), edge: e});
-      }
-    });
-    return connections;`;
-        return expanderFilter;
+        const collection = this.graph.edgeCollection(collectionName).collection;
+        return collection.outEdges(documentHandle);
     }
     /**
     * collection traversal - Performs a traversal starting from the given
@@ -409,97 +349,117 @@ class ArangoGraph extends base_1.Arango {
     * opts.init, opts.expander, opts.sort
     * @return  {[Object]} edge traversal path
     */
-    traversal(startVertex, opts, collectionName, edgeName, data_flag, path_flag, aql) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let collection;
-            let traversedData;
-            if (_.isNil(startVertex)) {
-                throw new Error('missing start vertex name');
-            }
-            if (opts.lowest_common_ancestor) {
-                return this.findTreesCommonAncestor(startVertex, collectionName, edgeName);
-            }
-            let response = {
-                vertex_fields: [],
-                data: {},
-                paths: {}
-            };
-            if (aql && aql == true) {
-                // get all the first level childrens for the start vertex
-                let result = yield this.getAllChildrenNodes(startVertex, edgeName);
-                let finalResponse = [];
-                for (let item of result._result) {
-                    finalResponse.push(_.omit(item, ['_key', '_id', '_rev']));
-                }
-                response.data.value = Buffer.from(JSON.stringify(finalResponse));
-                return response;
-            }
-            const vertex = startVertex;
-            if (_.isArray(vertex)) {
-                throw new Error('Invalid number of starting vertices for traversal: ' + vertex.length);
-            }
-            for (let key in opts) {
-                if (_.isEmpty(opts[key])) {
-                    delete opts[key];
-                }
+    async traversal(vertices, collection, opts, filters) {
+        if (vertices) {
+            if (_.isEmpty(vertices.collection_name) && !_.isEmpty(vertices.start_vertex_id)) {
+                throw new Error(`missing collection name for vertex id ${vertices.start_vertex_id}`);
             }
-            if (opts && opts.filter) {
-                opts.filter = this.traversalFilter(opts.filter);
+            else if (!_.isEmpty(vertices.collection_name) && _.isEmpty(vertices.start_vertex_id)) {
+                throw new Error(`missing vertex id for collection_name ${vertices.collection_name}`);
             }
-            else if (opts && opts.expander) {
-                opts.expander = this.traversalExpander(opts.expander);
-            }
-            if (!opts) {
-                // make outbound traversal by default if not provided
-                opts = {};
-                opts.direction = 'outbound';
-            }
-            if (opts.uniqueness && _.isEmpty(opts.uniqueness.vertices)
-                && _.isEmpty(opts.uniqueness.edges)) {
-                delete opts.uniqueness;
-            }
-            try {
-                if (collectionName) {
-                    collection = this.graph.edgeCollection(collectionName);
-                    traversedData = yield collection.traversal(vertex, opts);
-                }
-                else {
-                    traversedData = yield this.graph.traversal(vertex, opts);
-                }
+        }
+        // vertices data
+        let vertexCollectionName, startVertexIds;
+        if (vertices) {
+            vertexCollectionName = vertices.collection_name;
+            startVertexIds = vertices.start_vertex_id;
+        }
+        // collection data
+        let collectionName, limit, offset, sort;
+        if (collection) {
+            collectionName = collection.collection_name;
+            limit = collection.limit;
+            offset = collection.offset;
+            sort = collection.sort;
+        }
+        if ((_.isUndefined(startVertexIds) || _.isNil(startVertexIds) || _.isEmpty(startVertexIds)) &&
+            (_.isUndefined(collectionName) || _.isNil(collectionName) || _.isEmpty(collectionName))) {
+            throw new Error('One of the Vertices or Collection should be defined');
+        }
+        // from either vertices or collections
+        const traversalCollectionName = collectionName && !_.isEmpty(collectionName) ? collectionName : vertexCollectionName;
+        if (!opts) {
+            opts = {};
+        }
+        // make outbound traversal by default if not provided
+        if (!opts.direction || _.isEmpty(opts.direction)) {
+            opts.direction = interface_1.Direction.OUTBOUND;
+        }
+        // default options
+        let defaultOptions = { uniqueVertices: 'global', bfs: true, uniqueEdges: 'path' };
+        let filter = '';
+        let rootFilter = '';
+        let limitFilter = '';
+        let sortFilter = '';
+        // include vertices in options if specified
+        if (opts.include_vertex) {
+            defaultOptions.vertexCollections = opts.include_vertex;
+        }
+        // include edges in options if specified
+        if (opts.include_edge) {
+            defaultOptions.edgeCollections = opts.include_edge;
+        }
+        // exclude vertices
+        if (opts.exclude_vertex) {
+            for (let excludeVertex of opts.exclude_vertex) {
+                filter = filter + ` FILTER v._id NOT LIKE "${excludeVertex}%" `;
             }
-            catch (err) {
-                throw { code: err.code, message: err.message };
+        }
+        // exclude edges
+        if (opts.exclude_edge) {
+            for (let excludeEdge of opts.exclude_edge) {
+                filter = filter + ` FILTER e._id NOT LIKE "${excludeEdge}%" `;
             }
-            let encodedData = new Set();
-            if (data_flag) {
-                if (traversedData.visited && traversedData.visited.vertices) {
-                    traversedData.visited.vertices = this.arrUnique(traversedData.visited.vertices);
-                    for (let vertice of traversedData.visited.vertices) {
-                        response.vertex_fields.push(_.pick(vertice, ['_id', '_key', '_rev', 'id']));
-                        encodedData.add(_.omit(vertice, ['_key', '_rev']));
-                    }
-                    response.data.value = common_1.encodeMessage(Array.from(encodedData));
-                }
+        }
+        const rootAndAssociationFilter = (0, utils_1.createGraphsAssociationFilter)(filters, opts.direction, traversalCollectionName, this.edgeDefConfig, filter);
+        // association fitler
+        filter = rootAndAssociationFilter.associationFilter;
+        // root filter
+        const rootEntityFilter = rootAndAssociationFilter.rootEntityFilter;
+        if (rootEntityFilter) {
+            rootFilter = (0, utils_1.buildGraphFilter)([rootEntityFilter]).q;
+        }
+        if (startVertexIds && startVertexIds.length > 0) {
+            if (rootFilter && !_.isEmpty(rootFilter)) {
+                rootFilter = ` obj.id IN ${JSON.stringify(startVertexIds)} || ${rootFilter}`;
             }
-            if (path_flag) {
-                if (traversedData.visited && traversedData.visited.paths) {
-                    traversedData.visited.paths = this.arrUnique(traversedData.visited.paths);
-                    const encodedPaths = common_1.encodeMessage(traversedData.visited.paths);
-                    response.paths.value = encodedPaths;
-                }
+            else {
+                rootFilter = ` obj.id IN ${JSON.stringify(startVertexIds)} `;
             }
-            return response;
-        });
+        }
+        // combined root filter
+        if (rootFilter && !_.isEmpty(rootFilter)) {
+            rootFilter = `FILTER ${rootFilter}`;
+        }
+        limitFilter = (0, utils_1.buildGraphLimiter)(limit, offset);
+        if (sort) {
+            sortFilter = (0, utils_1.buildGraphSorter)(sort);
+        }
+        let rootCursor, associationCursor;
+        try {
+            defaultOptions = JSON.stringify(defaultOptions);
+            // traversal data
+            const traversalQuery = `For obj IN ${traversalCollectionName} ${rootFilter} ${limitFilter} ${sortFilter}
+          FOR v, e, p IN 1..100 ${opts.direction} obj GRAPH "${this.graph.name}"
+          OPTIONS ${defaultOptions}
+          ${filter}
+          RETURN { v, e, p }`;
+            associationCursor = await this.db.query(traversalQuery);
+            const rootEntityQuery = `For obj IN ${traversalCollectionName} ${rootFilter} ${limitFilter} ${sortFilter} return obj`;
+            rootCursor = await this.db.query(rootEntityQuery);
+        }
+        catch (err) {
+            throw { code: err.code, message: err.message };
+        }
+        return { rootCursor, associationCursor };
     }
-    getAllChildrenNodes(startVertex, edgeName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const queryTpl = `FOR v IN 1..1 OUTBOUND @start_vertex @@edge_name RETURN v`;
-            const result = yield this.db.query(queryTpl, {
-                start_vertex: startVertex,
-                '@edge_name': edgeName
-            });
-            return result;
+    async getAllChildrenNodes(startVertex, edgeName) {
+        const queryTpl = `FOR v IN 1..1 OUTBOUND @start_vertex @@edge_name RETURN v`;
+        const result = await this.db.query(queryTpl, {
+            start_vertex: startVertex,
+            '@edge_name': edgeName
         });
+        return result;
     }
     arrUnique(arr) {
         let cleaned = [];
@@ -514,93 +474,6 @@ class ArangoGraph extends base_1.Arango {
         });
         return cleaned;
     }
-    /**
-     * Finds the lowest common ancestor between two nodes of a tree-shaped graph and returns the subtree in that node.
-     */
-    findTreesCommonAncestor(nodes, collectionName, edgeName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // preprocessing to get all the roots
-            const collection = this.graph.edgeCollection(edgeName).collection;
-            const roots = {};
-            for (let node of nodes) {
-                node = `${collectionName}/${node}`;
-                const result = yield collection.traversal(node, {
-                    direction: 'outbound'
-                });
-                // const result = await this.db.query(`FOR v IN 1..10000 OUTBOUND @vertex GRAPH @graph FILTER "${rawFilter}" RETURN v`, { graph: this.graph.name, vertex: node });
-                if (_.isEmpty(result.visited) || _.isEmpty(result.visited.vertices)) {
-                    if (!roots[node]) {
-                        roots[node] = [node];
-                    }
-                    continue;
-                }
-                const items = result.visited.vertices;
-                const root = _.isArray(items) ? items[items.length - 1] : items;
-                if (!roots[root._id]) {
-                    roots[root._id] = [node];
-                }
-                else {
-                    roots[root._id].push(node);
-                }
-            }
-            const that = this;
-            const findCommonAncestor = (nodeA, nodeB) => __awaiter(this, void 0, void 0, function* () {
-                const queryTpl = `LET firstPath = (FOR v IN 1..10000
-      OUTBOUND @vertex1 GRAPH @graph RETURN v)
-        FOR v,e,p IN 1..10000 OUTBOUND @vertex2 GRAPH @graph
-          LET pos = POSITION(firstPath, v, true)
-          FILTER pos != -1
-          LIMIT 1
-          let endPath = REVERSE(p.vertices)
-          return endPath`;
-                const result = yield that.db.query(queryTpl, {
-                    vertex1: nodeA,
-                    vertex2: nodeB,
-                    graph: that.graph.name
-                });
-                if (result.count == 0) {
-                    throw new Error('Unimplemented: hierarchical resources do not share the same root');
-                }
-                const item = yield result.next();
-                return item[0];
-            });
-            const lca = (nodeA, nodeList) => __awaiter(this, void 0, void 0, function* () {
-                if (nodeList.length > 1) {
-                    const slices = nodeList.slice(1, nodeList.length);
-                    return lca(nodeA, lca(nodes[0], slices));
-                }
-                else {
-                    const result = [yield findCommonAncestor(nodeA, nodeList[0])];
-                    return result;
-                }
-            });
-            let paths = []; // the edges allow us to build the tree
-            for (let root in roots) {
-                let ancestor;
-                if (roots[root].length == 1) {
-                    ancestor = root;
-                }
-                else {
-                    const list = roots[root];
-                    let vertex = yield lca(list[0], list.slice(1, list.length));
-                    if (_.isArray(vertex)) {
-                        vertex = vertex[0];
-                    }
-                    ancestor = vertex._id;
-                }
-                const traversal = yield collection.traversal(ancestor, {
-                    direction: 'inbound',
-                });
-                const visited = traversal.visited;
-                paths = paths.concat(visited.paths);
-            }
-            return {
-                paths: {
-                    value: common_1.encodeMessage(paths)
-                }
-            };
-        });
-    }
     /**
     * Adds the given edge definition to the graph.
     *
@@ -609,39 +482,37 @@ class ArangoGraph extends base_1.Arango {
     * @param  {Object} toVertice from vertice
     * @return  {Object} The added edge definition
     */
-    addEdgeDefinition(edgeName, fromVertice, toVertice) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(edgeName)) {
-                throw new Error('missing edge name');
-            }
-            if (_.isNil(fromVertice)) {
-                throw new Error('missing from vertice');
-            }
-            if (_.isNil(toVertice)) {
-                throw new Error('missing to vertice');
-            }
-            if (!_.isArray(fromVertice)) {
-                fromVertice = [fromVertice];
-            }
-            if (!_.isArray(toVertice)) {
-                toVertice = [toVertice];
-            }
-            let edgeDef;
-            try {
-                edgeDef = yield this.graph.addEdgeDefinition({
-                    collection: edgeName,
-                    from: fromVertice,
-                    to: toVertice
-                });
-            }
-            catch (err) {
-                // if edge def already exists return
-                if (err.message === `${edgeName} multi use of edge collection in edge def`) {
-                    return edgeDef;
-                }
-                throw { code: err.code, message: err.message };
+    async addEdgeDefinition(edgeName, fromVertice, toVertice) {
+        if (_.isNil(edgeName)) {
+            throw new Error('missing edge name');
+        }
+        if (_.isNil(fromVertice)) {
+            throw new Error('missing from vertice');
+        }
+        if (_.isNil(toVertice)) {
+            throw new Error('missing to vertice');
+        }
+        if (!_.isArray(fromVertice)) {
+            fromVertice = [fromVertice];
+        }
+        if (!_.isArray(toVertice)) {
+            toVertice = [toVertice];
+        }
+        let edgeDef;
+        try {
+            edgeDef = await this.graph.addEdgeDefinition({
+                collection: edgeName,
+                from: fromVertice,
+                to: toVertice
+            });
+        }
+        catch (err) {
+            // if edge def already exists return
+            if (err.message === `${edgeName} multi use of edge collection in edge def`) {
+                return edgeDef;
             }
-        });
+            throw { code: err.code, message: err.message };
+        }
     }
     /**
     *  Removes the edge definition with the given definitionName form the graph.
@@ -652,23 +523,19 @@ class ArangoGraph extends base_1.Arango {
     * associated with the definition will also be deleted from the database.
     * @return  {Object} replaced edge definition
     */
-    removeEdgeDefinition(definitionName, dropCollection) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(definitionName)) {
-                throw new Error('missing definition name');
-            }
-            return this.graph.removeEdgeDefinition(definitionName, dropCollection);
-        });
+    async removeEdgeDefinition(definitionName, dropCollection) {
+        if (_.isNil(definitionName)) {
+            throw new Error('missing definition name');
+        }
+        return this.graph.removeEdgeDefinition(definitionName, dropCollection);
     }
     /**
      * list graphs.
      *
      * @return  {Promise<any>} list all the graphs
      */
-    listGraphs() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.db.listGraphs();
-        });
+    async listGraphs() {
+        return this.db.listGraphs();
     }
     /**
      * Deletes the edge with the given documentHandle from the collection.
@@ -679,17 +546,15 @@ class ArangoGraph extends base_1.Arango {
      * or an edge (i.e. an object with an _id or _key property).
      * @return  {Object} removed Edge
      */
-    removeEdge(collectionName, documentHandle) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collectionName)) {
-                throw new Error('missing edge collection name');
-            }
-            if (_.isNil(documentHandle)) {
-                throw new Error('missing document handle');
-            }
-            const collection = this.graph.edgeCollection(collectionName);
-            return collection.remove(documentHandle);
-        });
+    async removeEdge(collectionName, documentHandle) {
+        if (_.isNil(collectionName)) {
+            throw new Error('missing edge collection name');
+        }
+        if (_.isNil(documentHandle)) {
+            throw new Error('missing document handle');
+        }
+        const collection = this.graph.edgeCollection(collectionName);
+        return collection.remove(documentHandle);
     }
 }
 exports.ArangoGraph = ArangoGraph;