Merge pull request #43 from Pchelolo/dep_updates

d00rman · web-flow · commit df1af07cf270 · 2018-03-26T12:10:07.000-03:00
Update dependencies and adapt to version 3 connection pool
diff --git a/index.js b/index.js
@@ -79,7 +79,7 @@ class RBSQLite {
         }
         const domain = req.params.domain;
         return this.store.get(domain, req.body)
-        .then((res) => ({
+        .then(res => ({
             status: res.items.length ? 200 : 404,
             body: res
         }))
@@ -146,7 +146,7 @@ class RBSQLite {
     getTableSchema(rb, req) {
         const domain = req.params.domain;
         return this.store.getTableSchema(domain, req.params.table)
-        .then((res) => ({
+        .then(res => ({
             status: 200,
             body: res.schema
         }))
@@ -173,7 +173,7 @@ class RBSQLite {
             // deleted
             status: 204
         })
-        .catch((e) => ({
+        .catch(e => ({
             status: 500,
             body: {
                 type: 'delete_error',
@@ -208,7 +208,7 @@ class RBSQLite {
 
 /**
  * Factory
- * @param options
+ * @param {Object} options
  * @return {Promise<registration>} with registration being the registration
  * object
  */
diff --git a/lib/SchemaMigrator.js b/lib/SchemaMigrator.js
@@ -50,10 +50,10 @@ class Attributes {
         const currSet = new Set(Object.keys(this.current));
         const propSet = new Set(Object.keys(this.proposed));
 
-        this.addColumns = Array.from(propSet).filter((x) => !currSet.has(x));
+        this.addColumns = Array.from(propSet).filter(x => !currSet.has(x));
         // TODO: null-out deleted columns
         // We can't delete the column in SQLite, but we would remove it from * projection
-        this.delColumns = Array.from(currSet).filter((x) => !propSet.has(x));
+        this.delColumns = Array.from(currSet).filter(x => !propSet.has(x));
     }
 
     _colType(col) {
@@ -62,7 +62,7 @@ class Attributes {
 
     _alterTableAdd(col) {
         const colIndex = this.newSchema.index
-           && this.newSchema.index.find((index) => index.attribute === col);
+           && this.newSchema.index.find(index => index.attribute === col);
         if (colIndex && colIndex.type === 'static') {
             if (!dbu.staticTableExist(this.oldSchema)) {
                 return dbu.buildStaticsTableSql(this.newSchema, this.table);
@@ -99,7 +99,7 @@ class Attributes {
 
 Attributes.prototype.validate = () => {};
 
-Attributes.prototype._alterTable = (fullTableName) => `ALTER TABLE [${fullTableName}]`;
+Attributes.prototype._alterTable = fullTableName => `ALTER TABLE [${fullTableName}]`;
 
 /**
  * Index definition migrations
@@ -111,8 +111,8 @@ class Index {
         this.currentSchema = parentMigrator.current;
         this.proposedSchema = parentMigrator.proposed;
 
-        this.addIndex = proposed.filter((x) => !this._hasSameIndex(this.current, x));
-        this.delIndex = current.filter((x) => !this._hasSameIndex(this.proposed, x));
+        this.addIndex = proposed.filter(x => !this._hasSameIndex(this.current, x));
+        this.delIndex = current.filter(x => !this._hasSameIndex(this.proposed, x));
 
         this.alteredColumns = [];
 
@@ -136,8 +136,8 @@ class Index {
     }
 
     validate() {
-        if (this.addIndex.some((index) => index.type !== 'static')
-            || this.delIndex.some((index) => index.type !== 'static')) {
+        if (this.addIndex.some(index => index.type !== 'static')
+            || this.delIndex.some(index => index.type !== 'static')) {
             throw new Error('Only static index additions and removals supported');
         }
         if (this.alteredColumns.length > 0) {
@@ -147,7 +147,7 @@ class Index {
 }
 
 Index.prototype._hasSameIndex = (indexes, proposedIndex) =>
-    indexes.some((idx) => idx.attribute === proposedIndex.attribute
+    indexes.some(idx => idx.attribute === proposedIndex.attribute
         && idx.type === proposedIndex.type
         && idx.order === proposedIndex.order);
 
@@ -212,7 +212,7 @@ class SchemaMigrator {
         this.proposed = proposed;
 
         this.migrators = Object.keys(migrationHandlers)
-        .map((key) => new migrationHandlers[key](this, current[key], proposed[key]));
+        .map(key => new migrationHandlers[key](this, current[key], proposed[key]));
 
         this._validate();
     }
@@ -225,11 +225,10 @@ class SchemaMigrator {
 
     /**
      * Perform any required migration tasks.
-     *
-     * @return a promise that resolves when the migration tasks are complete
+     * @return {Promise} a promise that resolves when the migration tasks are complete
      */
     migrate() {
-        return P.each(this.migrators, (migrator) => migrator.migrate());
+        return P.each(this.migrators, migrator => migrator.migrate());
     }
 }
 
diff --git a/lib/clientWrapper.js b/lib/clientWrapper.js
@@ -2,7 +2,7 @@
 
 const P = require('bluebird');
 const sqlite3 = require('sqlite3').verbose();
-const poolModule = require('generic-pool');
+const genericPool = require('generic-pool');
 
 P.promisifyAll(sqlite3, { suffix: '_p' });
 
@@ -20,29 +20,28 @@ class Wrapper {
         this.retryLimit = options.conf.retry_limit || 5;
         this.randomDelay = () => Math.ceil(Math.random() * delay);
 
-        this.connectionPool = new poolModule.Pool({
-            name: 'sqlite',
-            create(callback) {
-                const client = new sqlite3.Database(expandDBName(options));
-                callback(null, client);
+        this.connectionPool = genericPool.createPool({
+            create() {
+                return P.resolve(new sqlite3.Database(expandDBName(options)));
             },
             destroy(client) {
-                client.close();
-            },
+                return P.try(() => client.close());
+            }
+        },
+        {
             max: 1,
             idleTimeoutMillis: options.conf.pool_idle_timeout || 10000,
-            log: options.log
+            log: options.log,
+            Promise: P
         });
-        P.promisifyAll(this.connectionPool, { suffix: '_p' });
         this.readerConnection = new sqlite3.Database(expandDBName(options));
     }
 
     /**
      * Run a set of queries within a transaction.
-     *
-     * @param queries an array of query objects, containing sql field with SQL
+     * @param {Array} queries an array of query objects, containing sql field with SQL
      *        and params array with query parameters.
-     * @returns {*} operation promise
+     * @return {Promise} operation promise
      */
     run(queries) {
         let retryCount = 0;
@@ -53,7 +52,7 @@ class Wrapper {
             }
 
             return client.run_p('begin immediate')
-            .then(() => client)
+            .thenReturn(client)
             .catch((err) => {
                 if (err && err.cause
                         && err.cause.code === 'SQLITE_BUSY'
@@ -67,10 +66,10 @@ class Wrapper {
             });
         };
 
-        return this.connectionPool.acquire_p()
+        return this.connectionPool.acquire()
         .then(beginTransaction)
         .then((client) => {
-            queries = queries.filter((query) => query && query.sql);
+            queries = queries.filter(query => query && query.sql);
             return P.each(queries, (query) => {
                 if (this.conf.show_sql) {
                     this.log(query.sql);
@@ -83,27 +82,22 @@ class Wrapper {
                     this.log('rollback');
                 }
                 return client.run_p('rollback')
-                .finally(() => {
-                    this.connectionPool.release(client);
-                    throw err;
-                });
+                .finally(() => this.connectionPool.release(client))
+                .thenThrow(err);
             });
         })
         .then((client) => {
             this.log('commit');
             return client.run_p('commit')
-            .finally(() => {
-                this.connectionPool.release(client);
-            });
+            .finally(() => this.connectionPool.release(client));
         });
     }
 
     /**
      * Run read query and return a result promise
-     *
-     * @param query SQL query to execute
-     * @param params query parameters
-     * @returns {*} query result promise
+     * @param {Object} query SQL query to execute
+     * @param {Object} params query parameters
+     * @return {Promise} query result promise
      */
     all(query, params) {
         let retryCount = 0;
diff --git a/lib/db.js b/lib/db.js
@@ -100,7 +100,7 @@ class DB {
                     }
                     createOperation = migrator.migrate()
                     .then(() => {
-                        this.queryCache.keys().filter((key) => key.indexOf(tableName) === 0)
+                        this.queryCache.keys().filter(key => key.indexOf(tableName) === 0)
                         .forEach((key) => {
                             this.queryCache.del(key);
                         });
@@ -152,7 +152,7 @@ class DB {
 
         if (!this.schemaCache[tableName]) {
             return this._getSchema(tableName)
-            .then((schema) => deleteRequest(schema));
+            .then(schema => deleteRequest(schema));
         } else {
             const schema = this.schemaCache[tableName];
             delete this.schemaCache[tableName];
@@ -204,7 +204,7 @@ class DB {
         options = options || {};
         validator.validateGetRequest(req, schema);
         const buildResult = this._createGetQuery(tableName, req,
-                schema, options.includePreparedForDelete);
+            schema, options.includePreparedForDelete);
         return this.client.all(buildResult.sql, buildResult.params)
         .then((result) => {
             if (!result) {
diff --git a/lib/dbutils.js b/lib/dbutils.js
@@ -156,10 +156,10 @@ function generateConverters(schema) {
         const objType = setType ? setType[1] : schema.attributes[key];
         const objConverter = dbu.conversions[objType] || {};
         if (!objConverter.write) {
-            objConverter.write = (val) => val;
+            objConverter.write = val => val;
         }
         if (!objConverter.read) {
-            objConverter.read = (val) => val;
+            objConverter.read = val => val;
         }
         if (!objConverter.type) {
             objConverter.type = objType;
@@ -189,7 +189,7 @@ dbu.HTTPError = HTTPError;
 
 function getAllKeysOfTypes(schema, types) {
     return Object.keys(schema.iKeyMap)
-    .filter((key) => schema.iKeyMap[key]
+    .filter(key => schema.iKeyMap[key]
         && types.indexOf(schema.iKeyMap[key].type) >= 0);
 }
 
@@ -198,9 +198,9 @@ dbu.hashKey = function hashKey(key) {
     .update(key)
     .digest()
     .toString('base64')
-        // Replace [+/] from base64 with _ (illegal in Cassandra)
+    // Replace [+/] from base64 with _ (illegal in Cassandra)
     .replace(/[+/]/g, '_')
-        // Remove base64 padding, has no entropy
+    // Remove base64 padding, has no entropy
     .replace(/=+$/, '');
 };
 
@@ -276,7 +276,7 @@ function constructProj(query, schema) {
 function isStaticJoinNeeded(query, schema) {
     if (query && query.proj) {
         if (Array.isArray(query.proj)) {
-            return query.proj.some((key) => schema.iKeyMap[key]
+            return query.proj.some(key => schema.iKeyMap[key]
                 && schema.iKeyMap[key].type === 'static');
         } else if (query.proj.constructor === String) {
             return schema.iKeyMap[query.proj] && schema.iKeyMap[query.proj].type === 'static';
@@ -285,11 +285,11 @@ function isStaticJoinNeeded(query, schema) {
                 + `${query.proj} of type ${query.proj.constructor}`);
         }
     } else {
-        return Object.keys(schema.iKeyMap).some((key) => schema.iKeyMap[key].type === 'static');
+        return Object.keys(schema.iKeyMap).some(key => schema.iKeyMap[key].type === 'static');
     }
 }
 
-dbu.staticTableExist = (schema) => isStaticJoinNeeded(null, schema);
+dbu.staticTableExist = schema => isStaticJoinNeeded(null, schema);
 
 function constructLimit(query) {
     let sql = '';
@@ -451,11 +451,11 @@ function buildUpdateQuery(req, tableName, schema, dataKVMap, primaryKeyKVMap, ig
     let dataParams = [];
     const condition = buildCondition(Object.assign(primaryKeyKVMap, req.if), schema, true, true);
     let sql = `${ignore ? 'update or ignore ' : 'update '}[${tableName}_data] set `;
-    sql += Object.keys(dataKVMap).filter((column) =>
-        schema.iKeys.indexOf(column) < 0).map((column) => {
-            dataParams.push(dataKVMap[column]);
-            return `${dbu.fieldName(column)}= ?`;
-        }).join(',');
+    sql += Object.keys(dataKVMap).filter(column => schema.iKeys.indexOf(column) < 0)
+    .map((column) => {
+        dataParams.push(dataKVMap[column]);
+        return `${dbu.fieldName(column)}= ?`;
+    }).join(',');
     sql += ` where ${condition.query}`;
     dataParams = dataParams.concat(condition.params);
     return {
@@ -547,7 +547,7 @@ dbu.buildPutQuery = (req, tableName, schema, ignoreStatic) => {
         const staticSql = `insert or replace into [${tableName}_static] `
             + `(${Object.keys(staticKVMap).map(dbu.fieldName).join(', ')}) `
             + `values (${Object.keys(staticKVMap).map(() => '?').join(', ')})`;
-        const staticData = Object.keys(staticKVMap).map((key) => staticKVMap[key]);
+        const staticData = Object.keys(staticKVMap).map(key => staticKVMap[key]);
         queries.push({
             sql: staticSql,
             params: staticData
@@ -583,7 +583,7 @@ dbu.buildStaticsTableSql = (schema, tableName) => {
     }
     let sql = 'create table if not exists ';
     sql += `[${tableName}_static] (`;
-    sql += hashKeys.concat(staticFields).map((key) =>
+    sql += hashKeys.concat(staticFields).map(key =>
         `${dbu.fieldName(key)} ${schema.converters[schema.attributes[key]].type}`
     ).join(', ');
     sql += `, primary key (${hashKeys.map(dbu.fieldName).join(', ')}), `;
@@ -596,8 +596,8 @@ dbu.buildTableSql = (schema, tableName) => {
     const indexKeys = getAllKeysOfTypes(schema, ['hash', 'range']);
     let sql = `create table if not exists [${tableName}_data] (`;
     sql += Object.keys(schema.attributes)
-    .filter((attr) => !schema.iKeyMap[attr] || schema.iKeyMap[attr].type !== 'static')
-    .map((attr) => `${dbu.fieldName(attr)} ${schema.converters[schema.attributes[attr]].type}`)
+    .filter(attr => !schema.iKeyMap[attr] || schema.iKeyMap[attr].type !== 'static')
+    .map(attr => `${dbu.fieldName(attr)} ${schema.converters[schema.attributes[attr]].type}`)
     .join(', ');
     sql += `, primary key (${indexKeys.map(dbu.fieldName).join(', ')}) )`;
     return sql;
diff --git a/package.json b/package.json
