@restorecommerce/chassis-srv 0.3.3 → 0.3.7

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

@@ -1,17 +1,27 @@
 "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.Arango = void 0;
 const arangojs_1 = require("arangojs");
-const _ = require("lodash");
+const _ = __importStar(require("lodash"));
 const common_1 = require("./common");
 /**
  * ArangoDB database provider.
@@ -33,91 +43,89 @@ class Arango {
      * @param  {Object} options     options.limit, options.offset
      * @return {Promise<any>}  Promise for list of found documents.
      */
-    find(collectionName, filter, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collectionName) || !_.isString(collectionName) ||
-                _.isEmpty(collectionName)) {
-                throw new Error('invalid or missing collection argument for find operation');
-            }
-            let filterQuery = filter || {};
-            const opts = options || {};
-            let filterResult;
-            let bindVars;
-            let customFilter = '';
-            // checking if a custom query should be used
-            if (!_.isEmpty(opts.customQueries)) {
-                for (let queryName of opts.customQueries) {
-                    if (!this.customQueries.has(queryName)) {
-                        throw new Error(`custom query ${common_1.query} not found`);
-                    }
-                    const customQuery = this.customQueries.get(queryName);
-                    if (customQuery.type == 'query') {
-                        // standalone query
-                        const result = yield common_1.query(this.db, collectionName, customQuery.code, opts.customArguments || {}); // Cursor object
-                        return result.all(); // TODO: paginate
-                    }
-                    else {
-                        // filter
-                        customFilter += ` ${customQuery.code} `;
-                    }
+    async find(collectionName, filter, options) {
+        if (_.isNil(collectionName) || !_.isString(collectionName) ||
+            _.isEmpty(collectionName)) {
+            throw new Error('invalid or missing collection argument for find operation');
+        }
+        let filterQuery = filter || {};
+        const opts = options || {};
+        let filterResult;
+        let bindVars;
+        let customFilter = '';
+        // checking if a custom query should be used
+        if (!_.isEmpty(opts.customQueries)) {
+            for (let queryName of opts.customQueries) {
+                if (!this.customQueries.has(queryName)) {
+                    throw new Error(`custom query ${common_1.query} not found`);
+                }
+                const customQuery = this.customQueries.get(queryName);
+                if (customQuery.type == 'query') {
+                    // standalone query
+                    const result = await (0, common_1.query)(this.db, collectionName, customQuery.code, opts.customArguments || {}); // Cursor object
+                    return result.all(); // TODO: paginate
+                }
+                else {
+                    // filter
+                    customFilter += ` ${customQuery.code} `;
                 }
             }
-            if (!_.isArray(filterQuery)) {
-                filterQuery = [filterQuery];
-            }
-            if (_.isEmpty(filterQuery[0])) {
-                filterQuery = true;
-            }
-            else {
-                filterResult = common_1.buildFilter(filterQuery);
-                filterQuery = filterResult.q;
-            }
-            let sortQuery = common_1.buildSorter(opts);
-            let limitQuery = common_1.buildLimiter(opts);
-            let returnResult = common_1.buildReturn(opts);
-            let returnQuery = returnResult.q;
-            // return complete node in case no specific fields are specified
-            if (_.isEmpty(returnQuery)) {
-                returnQuery = 'RETURN node';
-            }
-            let queryString = `FOR node in @@collection FILTER ${filterQuery}`;
-            if (!_.isEmpty(customFilter)) {
-                queryString += customFilter;
-            }
-            queryString += ` ${sortQuery}
+        }
+        if (!_.isArray(filterQuery)) {
+            filterQuery = [filterQuery];
+        }
+        if (_.isEmpty(filterQuery[0])) {
+            filterQuery = true;
+        }
+        else {
+            filterResult = (0, common_1.buildFilter)(filterQuery);
+            filterQuery = filterResult.q;
+        }
+        let sortQuery = (0, common_1.buildSorter)(opts);
+        let limitQuery = (0, common_1.buildLimiter)(opts);
+        let returnResult = (0, common_1.buildReturn)(opts);
+        let returnQuery = returnResult.q;
+        // return complete node in case no specific fields are specified
+        if (_.isEmpty(returnQuery)) {
+            returnQuery = 'RETURN node';
+        }
+        let queryString = `FOR node in @@collection FILTER ${filterQuery}`;
+        if (!_.isEmpty(customFilter)) {
+            queryString += customFilter;
+        }
+        queryString += ` ${sortQuery}
       ${limitQuery} ${returnQuery}`;
-            let varArgs = {};
-            if (filterResult && filterResult.bindVarsMap) {
-                varArgs = filterResult.bindVarsMap;
-            }
-            let returnArgs = {};
-            if (returnResult && returnResult.bindVarsMap) {
-                returnArgs = returnResult.bindVarsMap;
-            }
-            let limitArgs;
-            if (_.isEmpty(limitQuery)) {
-                limitArgs = {};
-            }
-            else {
-                if (!_.isNil(opts.limit)) {
-                    limitArgs = { limit: opts.limit };
-                    if (!_.isNil(opts.offset)) {
-                        limitArgs = { offset: opts.offset, limit: opts.limit };
-                    }
+        let varArgs = {};
+        if (filterResult && filterResult.bindVarsMap) {
+            varArgs = filterResult.bindVarsMap;
+        }
+        let returnArgs = {};
+        if (returnResult && returnResult.bindVarsMap) {
+            returnArgs = returnResult.bindVarsMap;
+        }
+        let limitArgs;
+        if (_.isEmpty(limitQuery)) {
+            limitArgs = {};
+        }
+        else {
+            if (!_.isNil(opts.limit)) {
+                limitArgs = { limit: opts.limit };
+                if (!_.isNil(opts.offset)) {
+                    limitArgs = { offset: opts.offset, limit: opts.limit };
                 }
             }
-            varArgs = _.assign(varArgs, limitArgs);
-            varArgs = _.assign(varArgs, returnArgs);
-            bindVars = _.assign({
-                '@collection': collectionName
-            }, varArgs);
-            if (!_.isEmpty(customFilter) && opts.customArguments) {
-                bindVars = _.assign(bindVars, opts.customArguments);
-            }
-            const res = yield common_1.query(this.db, collectionName, queryString, bindVars);
-            const docs = yield res.all(); // TODO: paginate
-            return _.map(docs, common_1.sanitizeOutputFields);
-        });
+        }
+        varArgs = _.assign(varArgs, limitArgs);
+        varArgs = _.assign(varArgs, returnArgs);
+        bindVars = _.assign({
+            '@collection': collectionName
+        }, varArgs);
+        if (!_.isEmpty(customFilter) && opts.customArguments) {
+            bindVars = _.assign(bindVars, opts.customArguments);
+        }
+        const res = await (0, common_1.query)(this.db, collectionName, queryString, bindVars);
+        const docs = await res.all(); // TODO: paginate
+        return _.map(docs, common_1.sanitizeOutputFields);
     }
     /**
      * Find documents by id (_key).
@@ -126,35 +134,33 @@ class Arango {
      * @param  {String|array.String} ids  A single ID or multiple IDs.
      * @return {Promise<any>} A list of found documents.
      */
-    findByID(collectionName, ids) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collectionName) || !_.isString(collectionName) ||
-                _.isEmpty(collectionName)) {
-                throw new Error('invalid or missing collection argument for findByID operation');
-            }
-            if (_.isNil(ids)) {
-                throw new Error('invalid or missing ids argument for findByID operation');
-            }
-            if (!_.isArray(ids)) {
-                ids = [ids];
-            }
-            const filter = ids.map((id) => {
-                return { id };
-            });
-            let filterResult = common_1.buildFilter(filter);
-            let filterQuery = filterResult.q;
-            let varArgs = {};
-            if (filterResult && filterResult.bindVarsMap) {
-                varArgs = filterResult.bindVarsMap;
-            }
-            const queryString = `FOR node in @@collection FILTER ${filterQuery} RETURN node`;
-            const bindVars = Object.assign({
-                '@collection': collectionName
-            }, varArgs);
-            const res = yield common_1.query(this.db, collectionName, queryString, bindVars);
-            const docs = yield res.all();
-            return _.map(docs, common_1.sanitizeOutputFields);
+    async findByID(collectionName, ids) {
+        if (_.isNil(collectionName) || !_.isString(collectionName) ||
+            _.isEmpty(collectionName)) {
+            throw new Error('invalid or missing collection argument for findByID operation');
+        }
+        if (_.isNil(ids)) {
+            throw new Error('invalid or missing ids argument for findByID operation');
+        }
+        if (!_.isArray(ids)) {
+            ids = [ids];
+        }
+        const filter = ids.map((id) => {
+            return { id };
         });
+        let filterResult = (0, common_1.buildFilter)(filter);
+        let filterQuery = filterResult.q;
+        let varArgs = {};
+        if (filterResult && filterResult.bindVarsMap) {
+            varArgs = filterResult.bindVarsMap;
+        }
+        const queryString = `FOR node in @@collection FILTER ${filterQuery} RETURN node`;
+        const bindVars = Object.assign({
+            '@collection': collectionName
+        }, varArgs);
+        const res = await (0, common_1.query)(this.db, collectionName, queryString, bindVars);
+        const docs = await res.all();
+        return _.map(docs, common_1.sanitizeOutputFields);
     }
     /**
      * retreive the documents including the document handlers (_key, _id and _rev).
@@ -165,26 +171,24 @@ class Arango {
      * @param  {string[]} idsArray list of document ids
      * @returns  {Promise<any>} A list of documents including the document handlers
      */
-    getDocumentHandlers(collectionName, collection, documents, idsArray) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let ids = [];
-            if (documents && !_.isArray(documents)) {
-                documents = [documents];
-            }
-            if (documents && documents.length > 0) {
-                for (let doc of documents) {
-                    ids.push(doc.id);
-                }
-            }
-            if (!_.isEmpty(idsArray) && _.isArray(idsArray)) {
-                ids = idsArray;
+    async getDocumentHandlers(collectionName, collection, documents, idsArray) {
+        let ids = [];
+        if (documents && !_.isArray(documents)) {
+            documents = [documents];
+        }
+        if (documents && documents.length > 0) {
+            for (let doc of documents) {
+                ids.push(doc.id);
             }
-            let queryString = arangojs_1.aql `FOR node in ${collection}
+        }
+        if (!_.isEmpty(idsArray) && _.isArray(idsArray)) {
+            ids = idsArray;
+        }
+        let queryString = (0, arangojs_1.aql) `FOR node in ${collection}
       FILTER node.id IN ${ids} return node`;
-            const res = yield common_1.query(this.db, collectionName, queryString);
-            const docsWithSelector = yield res.all();
-            return docsWithSelector;
-        });
+        const res = await (0, common_1.query)(this.db, collectionName, queryString);
+        const docsWithSelector = await res.all();
+        return docsWithSelector;
     }
     /**
      * Find documents by filter and updates them with document.
@@ -192,53 +196,51 @@ class Arango {
      * @param  {String} collection Collection name
      * @param  {Object} updateDocuments  List of documents to update
      */
-    update(collectionName, updateDocuments) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let documents = _.cloneDeep(updateDocuments);
-            let updateDocsResponse = [];
-            if (_.isNil(collectionName) ||
-                !_.isString(collectionName) || _.isEmpty(collectionName)) {
-                throw new Error('invalid or missing collection argument for update operation');
-            }
-            if (_.isNil(documents)) {
-                throw new Error('invalid or missing document argument for update operation');
-            }
-            const collection = this.db.collection(collectionName);
-            const collectionExists = yield collection.exists();
-            if (!collectionExists) {
-                throw new Error(`Collection ${collectionName} does not exist for update operation`);
+    async update(collectionName, updateDocuments) {
+        let documents = _.cloneDeep(updateDocuments);
+        let updateDocsResponse = [];
+        if (_.isNil(collectionName) ||
+            !_.isString(collectionName) || _.isEmpty(collectionName)) {
+            throw new Error('invalid or missing collection argument for update operation');
+        }
+        if (_.isNil(documents)) {
+            throw new Error('invalid or missing document argument for update operation');
+        }
+        const collection = this.db.collection(collectionName);
+        const collectionExists = await collection.exists();
+        if (!collectionExists) {
+            throw new Error(`Collection ${collectionName} does not exist for update operation`);
+        }
+        if (!_.isArray(documents)) {
+            throw new Error(`Documents should be list for update operation`);
+        }
+        const docsWithHandlers = await this.getDocumentHandlers(collectionName, collection, documents);
+        // update _key for the input documents
+        for (let document of documents) {
+            let foundInDB = false;
+            for (let docWithHandler of docsWithHandlers) {
+                if (docWithHandler.id === document.id) {
+                    foundInDB = true;
+                    document._key = docWithHandler._key;
+                    break;
+                }
             }
-            if (!_.isArray(documents)) {
-                throw new Error(`Documents should be list for update operation`);
+            if (!foundInDB) {
+                // if document is not found in DB use the id itself as _key
+                // this key will return an array in response since it does not exist
+                document._key = document.id;
             }
-            const docsWithHandlers = yield this.getDocumentHandlers(collectionName, collection, documents);
-            // update _key for the input documents
-            for (let document of documents) {
-                let foundInDB = false;
-                for (let docWithHandler of docsWithHandlers) {
-                    if (docWithHandler.id === document.id) {
-                        foundInDB = true;
-                        document._key = docWithHandler._key;
-                        break;
-                    }
-                }
-                if (!foundInDB) {
-                    // if document is not found in DB use the id itself as _key
-                    // this key will return an array in response since it does not exist
-                    document._key = document.id;
-                }
+        }
+        let updatedDocs = await collection.updateAll(documents, { returnNew: true });
+        for (let doc of updatedDocs) {
+            if (doc && doc.new) {
+                updateDocsResponse.push((0, common_1.sanitizeOutputFields)(doc.new));
             }
-            let updatedDocs = yield collection.updateAll(documents, { returnNew: true });
-            for (let doc of updatedDocs) {
-                if (doc && doc.new) {
-                    updateDocsResponse.push(common_1.sanitizeOutputFields(doc.new));
-                }
-                else {
-                    updateDocsResponse.push(doc);
-                }
+            else {
+                updateDocsResponse.push(doc);
             }
-            return updateDocsResponse;
-        });
+        }
+        return updateDocsResponse;
     }
     /**
      * Find each document based on it's key and update it.
@@ -247,42 +249,40 @@ class Arango {
      * @param  {String} collectionName Collection name
      * @param {Object|Array.Object} documents
      */
-    upsert(collectionName, documents) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collectionName) ||
-                !_.isString(collectionName) || _.isEmpty(collectionName)) {
-                throw new Error('invalid or missing collection argument for upsert operation');
-            }
-            if (_.isNil(documents)) {
-                throw new Error('invalid or missing documents argument for upsert operation');
-            }
-            let docs = _.cloneDeep(documents);
-            if (!_.isArray(documents)) {
-                docs = [documents];
-            }
-            _.forEach(docs, (document, i) => {
-                docs[i] = common_1.sanitizeInputFields(document);
-            });
-            let upsertResponse = [];
-            const collection = this.db.collection(collectionName);
-            const collectionExists = yield collection.exists();
-            if (!collectionExists) {
-                throw new Error(`Collection ${collectionName} does not exist for upsert operation`);
-            }
-            let upsertedDocs = yield collection.saveAll(docs, { returnNew: true, overwrite: true });
-            if (!_.isArray(upsertedDocs)) {
-                upsertedDocs = [upsertedDocs];
+    async upsert(collectionName, documents) {
+        if (_.isNil(collectionName) ||
+            !_.isString(collectionName) || _.isEmpty(collectionName)) {
+            throw new Error('invalid or missing collection argument for upsert operation');
+        }
+        if (_.isNil(documents)) {
+            throw new Error('invalid or missing documents argument for upsert operation');
+        }
+        let docs = _.cloneDeep(documents);
+        if (!_.isArray(documents)) {
+            docs = [documents];
+        }
+        _.forEach(docs, (document, i) => {
+            docs[i] = (0, common_1.sanitizeInputFields)(document);
+        });
+        let upsertResponse = [];
+        const collection = this.db.collection(collectionName);
+        const collectionExists = await collection.exists();
+        if (!collectionExists) {
+            throw new Error(`Collection ${collectionName} does not exist for upsert operation`);
+        }
+        let upsertedDocs = await collection.saveAll(docs, { returnNew: true, overwrite: true });
+        if (!_.isArray(upsertedDocs)) {
+            upsertedDocs = [upsertedDocs];
+        }
+        for (let doc of upsertedDocs) {
+            if (doc && doc.new) {
+                upsertResponse.push((0, common_1.sanitizeOutputFields)(doc.new));
             }
-            for (let doc of upsertedDocs) {
-                if (doc && doc.new) {
-                    upsertResponse.push(common_1.sanitizeOutputFields(doc.new));
-                }
-                else {
-                    upsertResponse.push(doc);
-                }
+            else {
+                upsertResponse.push(doc);
             }
-            return upsertResponse;
-        });
+        }
+        return upsertResponse;
     }
     /**
      * Delete all documents with provided identifiers ids.
@@ -291,43 +291,41 @@ class Arango {
      * @param  {Object} ids list of document identifiers
      * @return  {Promise<any>} delete response
      */
-    delete(collectionName, ids) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collectionName) ||
-                !_.isString(collectionName) || _.isEmpty(collectionName)) {
-                throw new Error('invalid or missing collection argument');
-            }
-            if (_.isNil(ids) || _.isEmpty(ids)) {
-                throw new Error('invalid or missing document IDs argument for delete operation');
-            }
-            const collection = this.db.collection(collectionName);
-            const collectionExists = yield collection.exists();
-            if (!collectionExists) {
-                throw new Error(`Collection ${collectionName} does not exist for delete operation`);
-            }
-            // retreive _key for the give ids
-            const docsWithHandlers = yield this.getDocumentHandlers(collectionName, collection, null, ids);
-            for (let id of ids) {
-                // check if given id is present in docsWithHandlers
-                let foundDocInDB = false;
-                for (let doc of docsWithHandlers) {
-                    if (doc.id === id) {
-                        foundDocInDB = true;
-                        break;
-                    }
-                }
-                // if document is not found in DB use the id itself as _key
-                // this key will return an array in response since it does not exist
-                if (!foundDocInDB) {
-                    docsWithHandlers.push({ _key: id });
+    async delete(collectionName, ids) {
+        if (_.isNil(collectionName) ||
+            !_.isString(collectionName) || _.isEmpty(collectionName)) {
+            throw new Error('invalid or missing collection argument');
+        }
+        if (_.isNil(ids) || _.isEmpty(ids)) {
+            throw new Error('invalid or missing document IDs argument for delete operation');
+        }
+        const collection = this.db.collection(collectionName);
+        const collectionExists = await collection.exists();
+        if (!collectionExists) {
+            throw new Error(`Collection ${collectionName} does not exist for delete operation`);
+        }
+        // retreive _key for the give ids
+        const docsWithHandlers = await this.getDocumentHandlers(collectionName, collection, null, ids);
+        for (let id of ids) {
+            // check if given id is present in docsWithHandlers
+            let foundDocInDB = false;
+            for (let doc of docsWithHandlers) {
+                if (doc.id === id) {
+                    foundDocInDB = true;
+                    break;
                 }
             }
-            let deleteHandlerIds = [];
-            for (let doc of docsWithHandlers) {
-                deleteHandlerIds.push(doc._key);
+            // if document is not found in DB use the id itself as _key
+            // this key will return an array in response since it does not exist
+            if (!foundDocInDB) {
+                docsWithHandlers.push({ _key: id });
             }
-            return collection.removeAll(deleteHandlerIds);
-        });
+        }
+        let deleteHandlerIds = [];
+        for (let doc of docsWithHandlers) {
+            deleteHandlerIds.push(doc._key);
+        }
+        return collection.removeAll(deleteHandlerIds);
     }
     /**
      * Count all documents selected by filter.
@@ -335,37 +333,35 @@ class Arango {
      * @param  {String} collection Collection name
      * @param  {Object} filter
      */
-    count(collectionName, filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collectionName) ||
-                !_.isString(collectionName) || _.isEmpty(collectionName)) {
-                throw new Error('invalid or missing collection argument for count operation');
-            }
-            let filterQuery = filter || {};
-            let filterResult;
-            if (!_.isArray(filterQuery)) {
-                filterQuery = [filterQuery];
-            }
-            if (_.isEmpty(filterQuery[0])) {
-                filterQuery = true;
-            }
-            else {
-                filterResult = common_1.buildFilter(filterQuery);
-                filterQuery = filterResult.q;
-            }
-            let varArgs = {};
-            if (filterResult && filterResult.bindVarsMap) {
-                varArgs = filterResult.bindVarsMap;
-            }
-            let queryString = `FOR node in @@collection FILTER ${filterQuery} COLLECT WITH COUNT
+    async count(collectionName, filter) {
+        if (_.isNil(collectionName) ||
+            !_.isString(collectionName) || _.isEmpty(collectionName)) {
+            throw new Error('invalid or missing collection argument for count operation');
+        }
+        let filterQuery = filter || {};
+        let filterResult;
+        if (!_.isArray(filterQuery)) {
+            filterQuery = [filterQuery];
+        }
+        if (_.isEmpty(filterQuery[0])) {
+            filterQuery = true;
+        }
+        else {
+            filterResult = (0, common_1.buildFilter)(filterQuery);
+            filterQuery = filterResult.q;
+        }
+        let varArgs = {};
+        if (filterResult && filterResult.bindVarsMap) {
+            varArgs = filterResult.bindVarsMap;
+        }
+        let queryString = `FOR node in @@collection FILTER ${filterQuery} COLLECT WITH COUNT
       INTO length RETURN length`;
-            const bindVars = Object.assign({
-                '@collection': collectionName
-            }, varArgs);
-            const res = yield common_1.query(this.db, collectionName, queryString, bindVars);
-            const nn = yield res.all();
-            return nn[0];
-        });
+        const bindVars = Object.assign({
+            '@collection': collectionName
+        }, varArgs);
+        const res = await (0, common_1.query)(this.db, collectionName, queryString, bindVars);
+        const nn = await res.all();
+        return nn[0];
     }
     /**
      * When calling without a collection name,
@@ -374,20 +370,18 @@ class Arango {
      * delete all documents in specified collection in the database.
      * @param [string] collection Collection name.
      */
-    truncate(collection) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collection)) {
-                const collections = yield this.db.collections();
-                for (let i = 0; i < collections.length; i += 1) {
-                    const c = this.db.collection(collections[i].name);
-                    yield c.truncate();
-                }
-            }
-            else {
-                const c = this.db.collection(collection);
-                yield c.truncate();
+    async truncate(collection) {
+        if (_.isNil(collection)) {
+            const collections = await this.db.collections();
+            for (let i = 0; i < collections.length; i += 1) {
+                const c = this.db.collection(collections[i].name);
+                await c.truncate();
             }
-        });
+        }
+        else {
+            const c = this.db.collection(collection);
+            await c.truncate();
+        }
     }
     /**
      * Insert documents into database.
@@ -395,41 +389,39 @@ class Arango {
      * @param  {String} collection Collection name
      * @param  {Object|array.Object} documents  A single or multiple documents.
      */
-    insert(collectionName, documents) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (_.isNil(collectionName) || !_.isString(collectionName) || _.isEmpty(collectionName)) {
-                throw new Error('invalid or missing collection argument for insert operation');
-            }
-            if (_.isNil(documents)) {
-                throw new Error('invalid or missing documents argument for insert operation');
-            }
-            let docs = _.cloneDeep(documents);
-            if (!_.isArray(documents)) {
-                docs = [documents];
-            }
-            _.forEach(docs, (document, i) => {
-                docs[i] = common_1.sanitizeInputFields(document);
-            });
-            const collection = this.db.collection(collectionName);
-            const collectionExists = yield collection.exists();
-            if (!collectionExists) {
-                yield collection.create();
-            }
-            let insertResponse = [];
-            let createdDocs = yield collection.saveAll(docs, { returnNew: true });
-            if (!_.isArray(createdDocs)) {
-                createdDocs = [createdDocs];
+    async insert(collectionName, documents) {
+        if (_.isNil(collectionName) || !_.isString(collectionName) || _.isEmpty(collectionName)) {
+            throw new Error('invalid or missing collection argument for insert operation');
+        }
+        if (_.isNil(documents)) {
+            throw new Error('invalid or missing documents argument for insert operation');
+        }
+        let docs = _.cloneDeep(documents);
+        if (!_.isArray(documents)) {
+            docs = [documents];
+        }
+        _.forEach(docs, (document, i) => {
+            docs[i] = (0, common_1.sanitizeInputFields)(document);
+        });
+        const collection = this.db.collection(collectionName);
+        const collectionExists = await collection.exists();
+        if (!collectionExists) {
+            await collection.create();
+        }
+        let insertResponse = [];
+        let createdDocs = await collection.saveAll(docs, { returnNew: true });
+        if (!_.isArray(createdDocs)) {
+            createdDocs = [createdDocs];
+        }
+        for (let doc of createdDocs) {
+            if (doc && doc.new) {
+                insertResponse.push((0, common_1.sanitizeOutputFields)(doc.new));
             }
-            for (let doc of createdDocs) {
-                if (doc && doc.new) {
-                    insertResponse.push(common_1.sanitizeOutputFields(doc.new));
-                }
-                else {
-                    insertResponse.push(doc);
-                }
+            else {
+                insertResponse.push(doc);
             }
-            return insertResponse;
-        });
+        }
+        return insertResponse;
     }
     /**
      * Registers a custom AQL query.