Release 5.0.2

NEWS.md

@@ -1,58 +1,14 @@
 # Changelog
 
-## 5.4.0
-Released 2018-03-15
- - Upgrades Windshaft to 4.5.7 ([Mapnik top metrics](https://github.com/CartoDB/Windshaft/pull/597), [AttributesBackend allows multiple features if all the attributes are the same](https://github.com/CartoDB/Windshaft/pull/602))
- - Implemented middleware to authorize users via new Api Key system
- - Keep the old authorization system as fallback
- - Aggregation widget: Remove NULL categories in 'count' aggregations too
- - Update request to 2.85.0
- - Update camshaft to 0.61.4 (Fixes for AOI and Merge analyses)
- - Update windshaft to 4.6.0, which in turn updates @carto/mapnik to 3.6.2-carto.4 and related dependencies. It brings in a cache for rasterized symbols. See https://github.com/CartoDB/node-mapnik/blob/v3.6.2-carto/CHANGELOG.carto.md#362-carto4
- - PostGIS: Variables in postgis SQL queries must now additionally be wrapped in `!` (refs [#29](https://github.com/CartoDB/mapnik/issues/29), [mapnik/#3618](https://github.com/mapnik/mapnik/pull/3618)):
-```sql
--- Before
-SELECT ... WHERE trait = @variable
-
--- Now
-SELECT ... WHERE trait = !@variable!
-```
-
-## 5.3.1
-Released 2018-02-13
- - Improve the speed of the aggregation dataview #865
-
-## 5.3.0
-Released 2018-02-12
- - Upgrades redis-mpool to 0.5.0
- - Upgrades windshaft to 4.5.2
- - Upgrades cartodb-redis to 0.15.0
- - Adds metrics option to the Mapnik renderer
- - Upgrades camshadft to 0.61.2
-
-## 5.2.1
-Released 2018-02-01
-
-Bug Fixes:
-- Allow use of aggregation with attributes #861
-
-## 5.2.0
-Released 2018-02-01
+## 5.0.2
+Released 2018-07-27
 
 Announcements:
- - Upgrade windshaft to [4.3.3](https://github.com/CartoDB/windshaft/releases/tag/4.3.2) adding support for cache-features' in Mapnik/CartoDB layers.
-
-## 5.1.0
-Released 2018-01-30
-New features:
- - Now mapnik has support for fine-grained metrics.
- - Variables can be passed for later substitution in postgis datasource.
-
-Announcements:
- - Upgrade windshaft to [4.3.1](https://github.com/CartoDB/windshaft/releases/tag/4.3.1). Underneath it upgrades mapnik and all the related dependencies.
+- Upgrades camshaft to [0.62.1](https://github.com/CartoDB/camshaft/releases/tag/0.62.1):
+  - Add support for batch street-level geocoding analysis.
 
 ## 5.0.1
-Released 2018-01-29
+Released 2018-01-20
 
 Bug Fixes:
 - Allow aggregation for queries with no the_geom (only the_geom_webmercator) #856

config/environments/development.js.example

@@ -204,13 +204,8 @@ var config = {
               // which cost is no more expensive than snapping and results are
               // much closer to the original geometry
               removeRepeatedPoints: false // this requires postgis >=2.2
-          },
-          // If enabled Mapnik will reuse the features retrieved from the database
-          // instead of requesting them once per style inside a layer
-          'cache-features': true,
+          }
 
-          // Require metrics to the renderer
-          metrics: false
       },
       http: {
           timeout: 2000, // the timeout in ms for a http tile request

config/environments/production.js.example

@@ -198,14 +198,7 @@ var config = {
               // which cost is no more expensive than snapping and results are
               // much closer to the original geometry
               removeRepeatedPoints: false // this requires postgis >=2.2
-          },
-
-          // If enabled Mapnik will reuse the features retrieved from the database
-          // instead of requesting them once per style inside a layer
-          'cache-features': true,
-
-          // Require metrics to the renderer
-          metrics: false
+          }
 
       },
       http: {

config/environments/staging.js.example

@@ -198,14 +198,7 @@ var config = {
               // which cost is no more expensive than snapping and results are
               // much closer to the original geometry
               removeRepeatedPoints: false // this requires postgis >=2.2
-          },
-
-          // If enabled Mapnik will reuse the features retrieved from the database
-          // instead of requesting them once per style inside a layer
-          'cache-features': true,
-
-          // Require metrics to the renderer
-          metrics: false
+          }
 
       },
       http: {

config/environments/test.js.example

@@ -197,14 +197,7 @@ var config = {
               // which cost is no more expensive than snapping and results are
               // much closer to the original geometry
               removeRepeatedPoints: false // this requires postgis >=2.2
-          },
-
-          // If enabled Mapnik will reuse the features retrieved from the database
-          // instead of requesting them once per style inside a layer
-          'cache-features': true,
-
-          // Require metrics to the renderer
-          metrics: false
+          }
       },
       http: {
           timeout: 2000, // the timeout in ms for a http tile request

lib/cartodb/api/auth_api.js

@@ -1,4 +1,5 @@
-var _ = require('underscore'); // AUTH_FALLBACK
+var assert = require('assert');
+var step = require('step');
 
 /**
  *
@@ -46,113 +47,39 @@ AuthApi.prototype.authorizedBySigner = function(res, callback) {
     });
 };
 
-function isValidApiKey(apikey) {
-    return apikey.type &&
-        apikey.user &&
-        apikey.databasePassword &&
-        apikey.databaseRole;
-}
-
 // Check if a request is authorized by api_key
 //
 // @param user
-// @param res express response object
+// @param req express request object
 // @param callback function(err, authorized)
 //        NOTE: authorized is expected to be 0 or 1 (integer)
 //
-AuthApi.prototype.authorizedByAPIKey = function(user, res, callback) {
-    const apikeyToken = res.locals.api_key;
-    const basicAuthUsername = res.locals.basicAuthUsername;
-
-    if ( ! apikeyToken ) {
-        return callback(null, false); // no api key, no authorization...
+AuthApi.prototype.authorizedByAPIKey = function(user, req, callback) {
+    var givenKey = req.query.api_key || req.query.map_key;
+    if ( ! givenKey && req.body ) {
+        // check also in request body
+        givenKey = req.body.api_key || req.body.map_key;
+    }
+    if ( ! givenKey ) {
+        return callback(null, 0); // no api key, no authorization...
     }
 
-    this.metadataBackend.getApikey(user, apikeyToken, (err, apikey) => {
-        if (err) {
-            if (isNameNotFoundError(err)) {
-                err.http_status = 404;
-            }
+    var self = this;
 
-            return callback(err);
+    step(
+        function () {
+            self.metadataBackend.getUserMapKey(user, this);
+        },
+        function checkApiKey(err, val){
+            assert.ifError(err);
+            return val && givenKey === val;
+        },
+        function finish(err, authorized) {
+            callback(err, authorized);
         }
-
-        //Remove this block when Auth fallback is not used anymore
-        // AUTH_FALLBACK
-        apikey.databaseRole = composeUserDatabase(apikey);
-        apikey.databasePassword = composeDatabasePassword(apikey);
-
-        if ( !isValidApiKey(apikey)) {
-            const error = new Error('Unauthorized');
-            error.type = 'auth';
-            error.subtype = 'api-key-not-found';
-            error.http_status = 401;
-
-            return callback(error);
-        }
-
-        if (!usernameMatches(basicAuthUsername, res.locals.user)) {
-            const error = new Error('Forbidden');
-            error.type = 'auth';
-            error.subtype = 'api-key-username-mismatch';
-            error.http_status = 403;
-
-            return callback(error);
-        }
-
-        if (!apikey.grantsMaps) {
-            const error = new Error('Forbidden');
-            error.type = 'auth';
-            error.subtype = 'api-key-does-not-grant-access';
-            error.http_status = 403;
-
-            return callback(error);
-        }
-
-        return callback(null, true);
-    });
+    );
 };
 
-//Remove this block when Auth fallback is not used anymore
-// AUTH_FALLBACK
-function composeUserDatabase (apikey) {
-    if (shouldComposeUserDatabase(apikey)) {
-        return _.template(global.environment.postgres_auth_user, apikey);
-    }
-
-    return apikey.databaseRole;
-}
-
-//Remove this block when Auth fallback is not used anymore
-// AUTH_FALLBACK
-function composeDatabasePassword (apikey) {
-    if (shouldComposeDatabasePassword(apikey)) {
-        return global.environment.postgres.password;
-    }
-
-    return apikey.databasePassword;
-}
-
-//Remove this block when Auth fallback is not used anymore
-// AUTH_FALLBACK
-function shouldComposeDatabasePassword (apikey) {
-    return !apikey.databasePassword && global.environment.postgres.password;
-}
-
-//Remove this block when Auth fallback is not used anymore
-// AUTH_FALLBACK
-function shouldComposeUserDatabase(apikey) {
-    return !apikey.databaseRole && apikey.user_id && global.environment.postgres_auth_user;
-}
-
-function isNameNotFoundError (err) {
-    return err.message && -1 !== err.message.indexOf('name not found');
-}
-
-function usernameMatches (basicAuthUsername, requestUsername) {
-    return !(basicAuthUsername && (basicAuthUsername !== requestUsername));
-}
-
 /**
  * Check access authorization
  *
@@ -161,57 +88,51 @@ function usernameMatches (basicAuthUsername, requestUsername) {
  * @param callback function(err, allowed) is access allowed not?
  */
 AuthApi.prototype.authorize = function(req, res, callback) {
+    var self = this;
     var user = res.locals.user;
 
-    this.authorizedByAPIKey(user, res, (err, isAuthorizedByApikey) => {
-        if (err) {
-            return callback(err);
-        }
+    step(
+        function () {
+            self.authorizedByAPIKey(user, req, this);
+        },
+        function checkApiKey(err, authorized){
+            req.profiler.done('authorizedByAPIKey');
+            assert.ifError(err);
 
-        if (isAuthorizedByApikey) {
-            return this.pgConnection.setDBAuth(user, res.locals, 'regular', function (err) {
-                req.profiler.done('setDBAuth');
+            // if not authorized by api_key, continue
+            if (!authorized)  {
+                // not authorized by api_key, check if authorized by signer
+                return self.authorizedBySigner(res, this);
+            }
 
-                if (err) {
-                    return callback(err);
-                }
-
-                callback(null, true);
+            // authorized by api key, login as the given username and stop
+            self.pgConnection.setDBAuth(user, res.locals, function(err) {
+                callback(err, true); // authorized (or error)
             });
-        }
-
-        this.authorizedBySigner(res, (err, isAuthorizedBySigner) => {
+        },
+        function checkSignAuthorized(err, authorized) {
             if (err) {
                 return callback(err);
             }
 
-            if (isAuthorizedBySigner) {
-                return this.pgConnection.setDBAuth(user, res.locals, 'master', function (err) {
-                    req.profiler.done('setDBAuth');
+            if ( ! authorized ) {
+                // request not authorized by signer.
 
-                    if (err) {
-                        return callback(err);
-                    }
+                // if no signer name was given, let dbparams and
+                // PostgreSQL do the rest.
+                //
+                if ( ! res.locals.signer ) {
+                    return callback(null, true); // authorized so far
+                }
 
-                    callback(null, true);
-                });
+                // if signer name was given, return no authorization
+                return callback(null, false);
             }
 
-            // if no signer name was given, use default api key
-            if (!res.locals.signer) {
-                return this.pgConnection.setDBAuth(user, res.locals, 'default', function (err) {
-                    req.profiler.done('setDBAuth');
-
-                    if (err) {
-                        return callback(err);
-                    }
-
-                    callback(null, true);
-                });
-            }
-
-            // if signer name was given, return no authorization
-            return callback(null, false);
-        });
-    });
+            self.pgConnection.setDBAuth(user, res.locals, function(err) {
+                req.profiler.done('setDBAuth');
+                callback(err, true); // authorized (or error)
+            });
+        }
+    );
 };

lib/cartodb/backends/pg_connection.js

@@ -1,6 +1,7 @@
+var assert = require('assert');
+var step = require('step');
 var PSQL = require('cartodb-psql');
 var _ = require('underscore');
-const debug = require('debug')('cachechan');
 
 function PgConnection(metadataBackend) {
     this.metadataBackend = metadataBackend;
@@ -19,85 +20,45 @@ module.exports = PgConnection;
 //
 // @param callback function(err)
 //
-PgConnection.prototype.setDBAuth = function(username, params, apikeyType, callback) {
-    if (apikeyType === 'master') {
-        this.metadataBackend.getMasterApikey(username, (err, apikey) => {
-            if (err) {
-                if (isNameNotFoundError(err)) {
-                    err.http_status = 404;
-                }
-                return callback(err);
+PgConnection.prototype.setDBAuth = function(username, params, callback) {
+    var self = this;
+
+    var user_params = {};
+    var auth_user = global.environment.postgres_auth_user;
+    var auth_pass = global.environment.postgres_auth_pass;
+    step(
+        function getId() {
+            self.metadataBackend.getUserId(username, this);
+        },
+        function(err, user_id) {
+            assert.ifError(err);
+            user_params.user_id = user_id;
+            var dbuser = _.template(auth_user, user_params);
+            _.extend(params, {dbuser:dbuser});
+
+            // skip looking up user_password if postgres_auth_pass
+            // doesn't contain the "user_password" label
+            if (!auth_pass || ! auth_pass.match(/\buser_password\b/) ) {
+                return null;
             }
 
-            params.dbuser = apikey.databaseRole;
-            params.dbpassword = apikey.databasePassword;
-
-            //Remove this block when Auth fallback is not used anymore
-            // AUTH_FALLBACK
-            if (!params.dbuser && apikey.user_id && global.environment.postgres_auth_user) {
-                params.dbuser = _.template(global.environment.postgres_auth_user, apikey);
+            self.metadataBackend.getUserDBPass(username, this);
+        },
+        function(err, user_password) {
+            assert.ifError(err);
+            user_params.user_password = user_password;
+            if ( auth_pass ) {
+                var dbpass = _.template(auth_pass, user_params);
+                _.extend(params, {dbpassword:dbpass});
             }
-
-            return callback();
-        });
-    } else if (apikeyType === 'regular') { //Actually it can be any type of api key
-        this.metadataBackend.getApikey(username, params.api_key, (err, apikey) => {
-            if (err) {
-                if (isNameNotFoundError(err)) {
-                    err.http_status = 404;
-                }
-                return callback(err);
-            }
-
-            params.dbuser = apikey.databaseRole;
-            params.dbpassword = apikey.databasePassword;
-
-            //Remove this block when Auth fallback is not used anymore
-            // AUTH_FALLBACK
-            // master apikey has been recreated from user's metadata
-            if (!params.dbuser && apikey.user_id && apikey.type === 'master' && global.environment.postgres_auth_user) {
-                params.dbuser = _.template(global.environment.postgres_auth_user, apikey);
-            }
-
-            //Remove this block when Auth fallback is not used anymore
-            // AUTH_FALLBACK
-            // default apikey has been recreated from user's metadata
-            if (!params.dbpassword && global.environment.postgres.password) {
-                params.dbpassword = global.environment.postgres.password;
-            }
-
-            return callback();
-        });
-    } else if (apikeyType === 'default') {
-        this.metadataBackend.getApikey(username, 'default_public', (err, apikey) => {
-            if (err) {
-                if (isNameNotFoundError(err)) {
-                    err.http_status = 404;
-                }
-                return callback(err);
-            }
-
-            params.dbuser = apikey.databaseRole;
-            params.dbpassword = apikey.databasePassword;
-
-            //Remove this block when Auth fallback is not used anymore
-            // AUTH_FALLBACK
-            if (!params.dbpassword && global.environment.postgres.password) {
-                params.dbpassword = global.environment.postgres.password;
-            }
-
-            return callback();
-        });
-    } else {
-        return callback(new Error(`Invalid Apikey type: ${apikeyType}, valid ones: master, regular, default`));
-    }
+            return true;
+        },
+        function finish(err) {
+            callback(err);
+        }
+    );
 };
 
-function isNameNotFoundError (err) {
-    return err.message && -1 !== err.message.indexOf('name not found');
-}
-
-
 // Set db connection parameters to those for the given username
 //
 // @param dbowner cartodb username of database owner,
@@ -110,31 +71,37 @@ function isNameNotFoundError (err) {
 // @param callback function(err)
 //
 PgConnection.prototype.setDBConn = function(dbowner, params, callback) {
+    var self = this;
+    // Add default database connection parameters
+    // if none given
     _.defaults(params, {
-        // dbuser: global.environment.postgres.user,
-        // dbpassword: global.environment.postgres.password,
+        dbuser: global.environment.postgres.user,
+        dbpassword: global.environment.postgres.password,
         dbhost: global.environment.postgres.host,
         dbport: global.environment.postgres.port
     });
-
-    this.metadataBackend.getUserDBConnectionParams(dbowner, (err, dbParams) => {
-        if (err) {
-            return callback(err);
+    step(
+        function getConnectionParams() {
+            self.metadataBackend.getUserDBConnectionParams(dbowner, this);
+        },
+        function extendParams(err, dbParams){
+            assert.ifError(err);
+            // we don't want null values or overwrite a non public user
+            if (params.dbuser !== 'publicuser' || !dbParams.dbuser) {
+                delete dbParams.dbuser;
+            }
+            if ( dbParams ) {
+                _.extend(params, dbParams);
+            }
+            return null;
+        },
+        function finish(err) {
+            callback(err);
         }
-
-        // we don’t want null values or overwrite a non public user
-        if (params.dbuser !== 'publicuser' || !dbParams.dbuser) {
-            delete dbParams.dbuser;
-        }
-
-        if (dbParams) {
-            _.extend(params, dbParams);
-        }
-
-        callback();
-    });
+    );
 };
 
+
 /**
  * Returns a `cartodb-psql` object for a given username.
  * @param {String} username
@@ -142,37 +109,28 @@ PgConnection.prototype.setDBConn = function(dbowner, params, callback) {
  */
 
 PgConnection.prototype.getConnection = function(username, callback) {
-    debug("getConn1");
+    var self = this;
 
-    this.getDatabaseParams(username, (err, databaseParams) => {
-        if (err) {
-            return callback(err);
+    var params = {};
+
+    require('debug')('cachechan')("getConn1");
+    step(
+        function setAuth() {
+            self.setDBAuth(username, params, this);
+        },
+        function setConn(err) {
+            assert.ifError(err);
+            self.setDBConn(username, params, this);
+        },
+        function openConnection(err) {
+            assert.ifError(err);
+            return callback(err, new PSQL({
+                user: params.dbuser,
+                pass: params.dbpass,
+                host: params.dbhost,
+                port: params.dbport,
+                dbname: params.dbname
+            }));
         }
-        return callback(err, new PSQL({
-            user: databaseParams.dbuser,
-            pass: databaseParams.dbpass,
-            host: databaseParams.dbhost,
-            port: databaseParams.dbport,
-            dbname: databaseParams.dbname
-        }));
-
-    });
-};
-
-PgConnection.prototype.getDatabaseParams = function(username, callback) {
-    const databaseParams = {};
-
-    this.setDBAuth(username, databaseParams, 'master', err => {
-        if (err) {
-            return callback(err);
-        }
-
-        this.setDBConn(username, databaseParams, err => {
-            if (err) {
-                return callback(err);
-            }
-
-            callback(null, databaseParams);
-        });
-    });
+    );
 };

lib/cartodb/backends/pg_query_runner.js

@@ -1,4 +1,6 @@
+var assert = require('assert');
 var PSQL = require('cartodb-psql');
+var step = require('step');
 
 function PgQueryRunner(pgConnection) {
     this.pgConnection = pgConnection;
@@ -14,23 +16,31 @@ module.exports = PgQueryRunner;
  * @param {Function} callback function({Error}, {Array}) second argument is guaranteed to be an array
  */
 PgQueryRunner.prototype.run = function(username, query, callback) {
+    var self = this;
 
-    this.pgConnection.getDatabaseParams(username, (err, databaseParams) => {
-        if (err) {
-            return callback(err);
+    var params = {};
+
+    step(
+        function setAuth() {
+            self.pgConnection.setDBAuth(username, params, this);
+        },
+        function setConn(err) {
+            assert.ifError(err);
+            self.pgConnection.setDBConn(username, params, this);
+        },
+        function executeQuery(err) {
+            assert.ifError(err);
+            var psql = new PSQL({
+                user: params.dbuser,
+                pass: params.dbpass,
+                host: params.dbhost,
+                port: params.dbport,
+                dbname: params.dbname
+            });
+            psql.query(query, function(err, resultSet) {
+                resultSet = resultSet || {};
+                return callback(err, resultSet.rows || []);
+            });
         }
-
-        const psql = new PSQL({
-            user: databaseParams.dbuser,
-            pass: databaseParams.dbpass,
-            host: databaseParams.dbhost,
-            port: databaseParams.dbport,
-            dbname: databaseParams.dbname
-        });
-
-        psql.query(query, function (err, resultSet) {
-            resultSet = resultSet || {};
-            return callback(err, resultSet.rows || []);
-        });
-    });
+    );
 };

lib/cartodb/controllers/analyses.js

@@ -12,26 +12,26 @@ AnalysesController.prototype.register = function (app) {
     app.get(
         `${app.base_url_mapconfig}/analyses/catalog`,
         cors(),
-        userMiddleware(),
+        userMiddleware,
         this.prepareContext,
-        createPGClient(),
-        getDataFromQuery({ queryTemplate: catalogQueryTpl, key: 'catalog' }),
-        getDataFromQuery({ queryTemplate: tablesQueryTpl, key: 'tables' }),
-        prepareResponse(),
-        setCacheControlHeader(),
-        sendResponse(),
-        unauthorizedError()
+        this.createPGClient(),
+        this.getDataFromQuery({ queryTemplate: catalogQueryTpl, key: 'catalog' }),
+        this.getDataFromQuery({ queryTemplate: tablesQueryTpl, key: 'tables' }),
+        this.prepareResponse(),
+        this.setCacheControlHeader(),
+        this.sendResponse(),
+        this.unathorizedError()
     );
 };
 
-function createPGClient () {
+AnalysesController.prototype.createPGClient = function () {
     return function createPGClientMiddleware (req, res, next) {
         res.locals.pg = new PSQL(dbParamsFromReqParams(res.locals));
         next();
     };
-}
+};
 
-function getDataFromQuery({ queryTemplate, key }) {
+AnalysesController.prototype.getDataFromQuery = function ({ queryTemplate, key }) {
     const readOnlyTransactionOn = true;
 
     return function getCatalogMiddleware(req, res, next) {
@@ -48,9 +48,9 @@ function getDataFromQuery({ queryTemplate, key }) {
             next();
         }, readOnlyTransactionOn);
     };
-}
+};
 
-function prepareResponse () {
+AnalysesController.prototype.prepareResponse = function () {
     return function prepareResponseMiddleware (req, res, next) {
         const { catalog, tables } = res.locals;
 
@@ -91,16 +91,16 @@ function prepareResponse () {
 
         next();
     };
-}
+};
 
-function setCacheControlHeader () {
+AnalysesController.prototype.setCacheControlHeader = function () {
     return function setCacheControlHeaderMiddleware (req, res, next) {
         res.set('Cache-Control', 'public,max-age=10,must-revalidate');
         next();
     };
-}
+};
 
-function sendResponse () {
+AnalysesController.prototype.sendResponse = function() {
     return function sendResponseMiddleware (req, res) {
         res.status(200);
 
@@ -110,9 +110,9 @@ function sendResponse () {
             res.json(res.body);
         }
     };
-}
+};
 
-function unauthorizedError () {
+AnalysesController.prototype.unathorizedError = function () {
     return function unathorizedErrorMiddleware(err, req, res, next) {
         if (err.message.match(/permission\sdenied/)) {
             err = new Error('Unauthorized');
@@ -121,7 +121,7 @@ function unauthorizedError () {
 
         next(err);
     };
-}
+};
 
 const catalogQueryTpl = ctx => `
     SELECT analysis_def->>'type' as type, * FROM cdb_analysis_catalog WHERE username = '${ctx._username}'

lib/cartodb/controllers/layergroup.js

@@ -1,22 +1,20 @@
-const cors = require('../middleware/cors');
-const userMiddleware = require('../middleware/user');
-const allowQueryParams = require('../middleware/allow-query-params');
-const vectorError = require('../middleware/vector-error');
-const DataviewBackend = require('../backends/dataview');
-const AnalysisStatusBackend = require('../backends/analysis-status');
-const MapStoreMapConfigProvider = require('../models/mapconfig/provider/map-store-provider');
-const QueryTables = require('cartodb-query-tables');
-const SUPPORTED_FORMATS = {
-    grid_json: true,
-    json_torque: true,
-    torque_json: true,
-    png: true,
-    png32: true,
-    mvt: true
-};
+var assert = require('assert');
+var step = require('step');
+
+var cors = require('../middleware/cors');
+var userMiddleware = require('../middleware/user');
+var allowQueryParams = require('../middleware/allow-query-params');
+var vectorError = require('../middleware/vector-error');
+
+var DataviewBackend = require('../backends/dataview');
+var AnalysisStatusBackend = require('../backends/analysis-status');
+
+var MapStoreMapConfigProvider = require('../models/mapconfig/provider/map-store-provider');
+
+var QueryTables = require('cartodb-query-tables');
 
 /**
- * @param {prepareContext} prepareContext
+ * @param {AuthApi} authApi
  * @param {PgConnection} pgConnection
  * @param {MapStore} mapStore
  * @param {TileBackend} tileBackend
@@ -48,119 +46,64 @@ function LayergroupController(prepareContext, pgConnection, mapStore, tileBacken
 module.exports = LayergroupController;
 
 LayergroupController.prototype.register = function(app) {
-    const { base_url_mapconfig: basePath } = app;
-
     app.get(
-        `${basePath}/:token/:z/:x/:y@:scale_factor?x.:format`,
+        app.base_url_mapconfig + '/:token/:z/:x/:y@:scale_factor?x.:format',
         cors(),
-        userMiddleware(),
+        userMiddleware,
         this.prepareContext,
-        createMapStoreMapConfigProvider(this.mapStore, this.userLimitsApi),
-        getTile(this.tileBackend, 'map_tile'),
-        setCacheControlHeader(),
-        setLastModifiedHeader(),
-        getAffectedTables(this.layergroupAffectedTables, this.pgConnection, this.mapStore),
-        setCacheChannelHeader(),
-        setSurrogateKeyHeader(this.surrogateKeysCache),
-        incrementSuccessMetrics(global.statsClient),
-        sendResponse(),
-        incrementErrorMetrics(global.statsClient),
-        tileError(),
+        this.tile.bind(this),
         vectorError()
     );
 
     app.get(
-        `${basePath}/:token/:z/:x/:y.:format`,
+        app.base_url_mapconfig + '/:token/:z/:x/:y.:format',
         cors(),
-        userMiddleware(),
+        userMiddleware,
         this.prepareContext,
-        createMapStoreMapConfigProvider(this.mapStore, this.userLimitsApi),
-        getTile(this.tileBackend, 'map_tile'),
-        setCacheControlHeader(),
-        setLastModifiedHeader(),
-        getAffectedTables(this.layergroupAffectedTables, this.pgConnection, this.mapStore),
-        setCacheChannelHeader(),
-        setSurrogateKeyHeader(this.surrogateKeysCache),
-        incrementSuccessMetrics(global.statsClient),
-        sendResponse(),
-        incrementErrorMetrics(global.statsClient),
-        tileError(),
+        this.tile.bind(this),
         vectorError()
     );
 
     app.get(
-        `${basePath}/:token/:layer/:z/:x/:y.(:format)`,
-        distinguishLayergroupFromStaticRoute(),
+        app.base_url_mapconfig + '/:token/:layer/:z/:x/:y.(:format)',
         cors(),
-        userMiddleware(),
+        userMiddleware,
+        validateLayerRouteMiddleware,
         this.prepareContext,
-        createMapStoreMapConfigProvider(this.mapStore, this.userLimitsApi),
-        getTile(this.tileBackend, 'maplayer_tile'),
-        setCacheControlHeader(),
-        setLastModifiedHeader(),
-        getAffectedTables(this.layergroupAffectedTables, this.pgConnection, this.mapStore),
-        setCacheChannelHeader(),
-        setSurrogateKeyHeader(this.surrogateKeysCache),
-        incrementSuccessMetrics(global.statsClient),
-        sendResponse(),
-        incrementErrorMetrics(global.statsClient),
-        tileError(),
+        this.layer.bind(this),
         vectorError()
     );
 
     app.get(
-        `${basePath}/:token/:layer/attributes/:fid`,
+        app.base_url_mapconfig + '/:token/:layer/attributes/:fid',
         cors(),
-        userMiddleware(),
+        userMiddleware,
         this.prepareContext,
-        createMapStoreMapConfigProvider(this.mapStore, this.userLimitsApi),
-        getFeatureAttributes(this.attributesBackend),
-        setCacheControlHeader(),
-        setLastModifiedHeader(),
-        getAffectedTables(this.layergroupAffectedTables, this.pgConnection, this.mapStore),
-        setCacheChannelHeader(),
-        setSurrogateKeyHeader(this.surrogateKeysCache),
-        sendResponse()
+        this.attributes.bind(this)
     );
 
-    const forcedFormat = 'png';
-
     app.get(
-        `${basePath}/static/center/:token/:z/:lat/:lng/:width/:height.:format`,
+        app.base_url_mapconfig + '/static/center/:token/:z/:lat/:lng/:width/:height.:format',
         cors(),
-        userMiddleware(),
+        userMiddleware,
         allowQueryParams(['layer']),
         this.prepareContext,
-        createMapStoreMapConfigProvider(this.mapStore, this.userLimitsApi, forcedFormat),
-        getPreviewImageByCenter(this.previewBackend),
-        setCacheControlHeader(),
-        setLastModifiedHeader(),
-        getAffectedTables(this.layergroupAffectedTables, this.pgConnection, this.mapStore),
-        setCacheChannelHeader(),
-        setSurrogateKeyHeader(this.surrogateKeysCache),
-        sendResponse()
+        this.center.bind(this)
     );
 
     app.get(
-        `${basePath}/static/bbox/:token/:west,:south,:east,:north/:width/:height.:format`,
+        app.base_url_mapconfig + '/static/bbox/:token/:west,:south,:east,:north/:width/:height.:format',
         cors(),
-        userMiddleware(),
+        userMiddleware,
         allowQueryParams(['layer']),
         this.prepareContext,
-        createMapStoreMapConfigProvider(this.mapStore, this.userLimitsApi, forcedFormat),
-        getPreviewImageByBoundingBox(this.previewBackend),
-        setCacheControlHeader(),
-        setLastModifiedHeader(),
-        getAffectedTables(this.layergroupAffectedTables, this.pgConnection, this.mapStore),
-        setCacheChannelHeader(),
-        setSurrogateKeyHeader(this.surrogateKeysCache),
-        sendResponse()
+        this.bbox.bind(this)
     );
 
     // Undocumented/non-supported API endpoint methods.
     // Use at your own peril.
 
-    const allowedDataviewQueryParams = [
+    var allowedDataviewQueryParams = [
         'filters', // json
         'own_filter', // 0, 1
         'no_filters', // 0, 1
@@ -176,465 +119,395 @@ LayergroupController.prototype.register = function(app) {
     ];
 
     app.get(
-        `${basePath}/:token/dataview/:dataviewName`,
+        app.base_url_mapconfig + '/:token/dataview/:dataviewName',
         cors(),
-        userMiddleware(),
+        userMiddleware,
         allowQueryParams(allowedDataviewQueryParams),
         this.prepareContext,
-        createMapStoreMapConfigProvider(this.mapStore, this.userLimitsApi),
-        getDataview(this.dataviewBackend),
-        setCacheControlHeader(),
-        setLastModifiedHeader(),
-        getAffectedTables(this.layergroupAffectedTables, this.pgConnection, this.mapStore),
-        setCacheChannelHeader(),
-        setSurrogateKeyHeader(this.surrogateKeysCache),
-        sendResponse()
+        this.dataview.bind(this)
     );
 
     app.get(
-        `${basePath}/:token/:layer/widget/:dataviewName`,
+        app.base_url_mapconfig + '/:token/:layer/widget/:dataviewName',
         cors(),
-        userMiddleware(),
+        userMiddleware,
         allowQueryParams(allowedDataviewQueryParams),
         this.prepareContext,
-        createMapStoreMapConfigProvider(this.mapStore, this.userLimitsApi),
-        getDataview(this.dataviewBackend),
-        setCacheControlHeader(),
-        setLastModifiedHeader(),
-        getAffectedTables(this.layergroupAffectedTables, this.pgConnection, this.mapStore),
-        setCacheChannelHeader(),
-        setSurrogateKeyHeader(this.surrogateKeysCache),
-        sendResponse()
+        this.dataview.bind(this)
     );
 
     app.get(
-        `${basePath}/:token/dataview/:dataviewName/search`,
+        app.base_url_mapconfig + '/:token/dataview/:dataviewName/search',
         cors(),
-        userMiddleware(),
+        userMiddleware,
         allowQueryParams(allowedDataviewQueryParams),
         this.prepareContext,
-        createMapStoreMapConfigProvider(this.mapStore, this.userLimitsApi),
-        dataviewSearch(this.dataviewBackend),
-        setCacheControlHeader(),
-        setLastModifiedHeader(),
-        getAffectedTables(this.layergroupAffectedTables, this.pgConnection, this.mapStore),
-        setCacheChannelHeader(),
-        setSurrogateKeyHeader(this.surrogateKeysCache),
-        sendResponse()
+        this.dataviewSearch.bind(this)
     );
 
     app.get(
-        `${basePath}/:token/:layer/widget/:dataviewName/search`,
+        app.base_url_mapconfig + '/:token/:layer/widget/:dataviewName/search',
         cors(),
-        userMiddleware(),
+        userMiddleware,
         allowQueryParams(allowedDataviewQueryParams),
         this.prepareContext,
-        createMapStoreMapConfigProvider(this.mapStore, this.userLimitsApi),
-        dataviewSearch(this.dataviewBackend),
-        setCacheControlHeader(),
-        setLastModifiedHeader(),
-        getAffectedTables(this.layergroupAffectedTables, this.pgConnection, this.mapStore),
-        setCacheChannelHeader(),
-        setSurrogateKeyHeader(this.surrogateKeysCache),
-        sendResponse()
+        this.dataviewSearch.bind(this)
     );
 
     app.get(
-        `${basePath}/:token/analysis/node/:nodeId`,
+        app.base_url_mapconfig + '/:token/analysis/node/:nodeId',
         cors(),
-        userMiddleware(),
+        userMiddleware,
         this.prepareContext,
-        analysisNodeStatus(this.analysisStatusBackend),
-        sendResponse()
+        this.analysisNodeStatus.bind(this)
     );
 };
 
-function distinguishLayergroupFromStaticRoute () {
-    return function distinguishLayergroupFromStaticRouteMiddleware(req, res, next) {
-        if (req.params.token === 'static') {
-            return next('route');
-        }
+LayergroupController.prototype.analysisNodeStatus = function(req, res, next) {
+    var self = this;
 
-        next();
-    };
-}
-
-function analysisNodeStatus (analysisStatusBackend) {
-    return function analysisNodeStatusMiddleware(req, res, next) {
-        analysisStatusBackend.getNodeStatus(res.locals, (err, nodeStatus, stats = {}) => {
-            req.profiler.add(stats);
+    step(
+        function retrieveNodeStatus() {
+            self.analysisStatusBackend.getNodeStatus(res.locals, this);
+        },
+        function finish(err, nodeStatus, stats) {
+            req.profiler.add(stats || {});
 
             if (err) {
                 err.label = 'GET NODE STATUS';
-                return next(err);
+                next(err);
+            } else {
+                self.sendResponse(req, res, nodeStatus, 200, {
+                    'Cache-Control': 'public,max-age=5',
+                    'Last-Modified': new Date().toUTCString()
+                });
             }
-
-            res.set({
-                'Cache-Control': 'public,max-age=5',
-                'Last-Modified': new Date().toUTCString()
-            });
-
-            res.body = nodeStatus;
-
-            next();
-        });
-    };
-}
-
-function getRequestParams(locals) {
-    const params = Object.assign({}, locals);
-
-    delete params.mapConfigProvider;
-    delete params.allowedQueryParams;
-
-    return params;
-}
-
-function createMapStoreMapConfigProvider (mapStore, userLimitsApi, forcedFormat = null) {
-    return function createMapStoreMapConfigProviderMiddleware (req, res, next) {
-        const { user } = res.locals;
-
-        const params = getRequestParams(res.locals);
-
-        if (forcedFormat) {
-            params.format = forcedFormat;
-            params.layer = params.layer || 'all';
         }
+    );
+};
 
-        res.locals.mapConfigProvider = new MapStoreMapConfigProvider(mapStore, user, userLimitsApi, params);
+LayergroupController.prototype.dataview = function(req, res, next) {
+    var self = this;
 
-        next();
-    };
-}
-
-function getDataview (dataviewBackend) {
-    return function getDataviewMiddleware (req, res, next) {
-        const { user, mapConfigProvider } = res.locals;
-        const params = getRequestParams(res.locals);
-
-        dataviewBackend.getDataview(mapConfigProvider, user, params, (err, dataview, stats = {}) => {
-            req.profiler.add(stats);
+    step(
+        function retrieveDataview() {
+            var mapConfigProvider = new MapStoreMapConfigProvider(
+                self.mapStore, res.locals.user, self.userLimitsApi, res.locals
+            );
+            self.dataviewBackend.getDataview(
+                mapConfigProvider,
+                res.locals.user,
+                res.locals,
+                this
+            );
+        },
+        function finish(err, dataview, stats) {
+            req.profiler.add(stats || {});
 
             if (err) {
                 err.label = 'GET DATAVIEW';
-                return next(err);
+                next(err);
+            } else {
+                self.sendResponse(req, res, dataview, 200);
             }
+        }
+    );
+};
 
-            res.body = dataview;
+LayergroupController.prototype.dataviewSearch = function(req, res, next) {
+    var self = this;
 
-            next();
-        });
-    };
-}
-
-function dataviewSearch (dataviewBackend) {
-    return function dataviewSearchMiddleware (req, res, next) {
-        const { user, dataviewName, mapConfigProvider } = res.locals;
-        const params = getRequestParams(res.locals);
-
-        dataviewBackend.search(mapConfigProvider, user, dataviewName, params, (err, searchResult, stats = {}) => {
-            req.profiler.add(stats);
+    step(
+        function searchDataview() {
+            var mapConfigProvider = new MapStoreMapConfigProvider(
+                self.mapStore, res.locals.user, self.userLimitsApi, res.locals
+            );
+            self.dataviewBackend.search(mapConfigProvider, res.locals.user, req.params.dataviewName, res.locals, this);
+        },
+        function finish(err, searchResult, stats) {
+            req.profiler.add(stats || {});
 
             if (err) {
                 err.label = 'GET DATAVIEW SEARCH';
-                return next(err);
+                next(err);
+            } else {
+                self.sendResponse(req, res, searchResult, 200);
             }
+        }
+    );
 
-            res.body = searchResult;
+};
 
-            next();
-        });
-    };
-}
+LayergroupController.prototype.attributes = function(req, res, next) {
+    var self = this;
 
-function getFeatureAttributes (attributesBackend) {
-    return function getFeatureAttributesMiddleware (req, res, next) {
-        req.profiler.start('windshaft.maplayer_attribute');
+    req.profiler.start('windshaft.maplayer_attribute');
 
-        const { mapConfigProvider } = res.locals;
-        const params = getRequestParams(res.locals);
-
-        attributesBackend.getFeatureAttributes(mapConfigProvider, params, false, (err, tile, stats = {}) => {
-            req.profiler.add(stats);
+    step(
+        function retrieveFeatureAttributes() {
+            var mapConfigProvider = new MapStoreMapConfigProvider(
+                self.mapStore, res.locals.user, self.userLimitsApi, res.locals
+            );
+            self.attributesBackend.getFeatureAttributes(mapConfigProvider, res.locals, false, this);
+        },
+        function finish(err, tile, stats) {
+            req.profiler.add(stats || {});
 
             if (err) {
                 err.label = 'GET ATTRIBUTES';
-                return next(err);
+                next(err);
+            } else {
+                self.sendResponse(req, res, tile, 200);
             }
+        }
+    );
 
-            res.body = tile;
+};
 
-            next();
-        });
-    };
-}
+// Gets a tile for a given token and set of tile ZXY coords. (OSM style)
+LayergroupController.prototype.tile = function(req, res, next) {
+    req.profiler.start('windshaft.map_tile');
+    this.tileOrLayer(req, res, next);
+};
+
+// Gets a tile for a given token, layer set of tile ZXY coords. (OSM style)
+LayergroupController.prototype.layer = function(req, res, next) {
+    req.profiler.start('windshaft.maplayer_tile');
+    this.tileOrLayer(req, res, next);
+};
+
+LayergroupController.prototype.tileOrLayer = function (req, res, next) {
+    var self = this;
+
+    step(
+        function mapController$getTileOrGrid() {
+            self.tileBackend.getTile(
+                new MapStoreMapConfigProvider(self.mapStore, res.locals.user, self.userLimitsApi, res.locals),
+                req.params, this
+            );
+        },
+        function mapController$finalize(err, tile, headers, stats) {
+            req.profiler.add(stats);
+            self.finalizeGetTileOrGrid(err, req, res, tile, headers, next);
+        }
+    );
+};
 
 function getStatusCode(tile, format){
-    return tile.length === 0 && format === 'mvt'? 204 : 200;
+    return tile.length===0 && format==='mvt'? 204:200;
 }
 
-function parseFormat (format = '') {
-    const prettyFormat = format.replace('.', '_');
-    return SUPPORTED_FORMATS[prettyFormat] ? prettyFormat : 'invalid';
-}
-
-function getTile (tileBackend, profileLabel = 'tile') {
-    return function getTileMiddleware (req, res, next) {
-        req.profiler.start(`windshaft.${profileLabel}`);
-
-        const { mapConfigProvider } = res.locals;
-        const params = getRequestParams(res.locals);
-
-        tileBackend.getTile(mapConfigProvider, params, (err, tile, headers, stats = {}) => {
-            req.profiler.add(stats);
-
-            if (err) {
-                return next(err);
-            }
-
-            if (headers) {
-                res.set(headers);
-            }
-
-            const formatStat = parseFormat(req.params.format);
-
-            res.statusCode = getStatusCode(tile, formatStat);
-            res.body = tile;
-
-            next();
-        });
+// This function is meant for being called as the very last
+// step by all endpoints serving tiles or grids
+LayergroupController.prototype.finalizeGetTileOrGrid = function(err, req, res, tile, headers, next) {
+    var supportedFormats = {
+        grid_json: true,
+        json_torque: true,
+        torque_json: true,
+        png: true,
+        png32: true,
+        mvt: true
     };
-}
 
-function getPreviewImageByCenter (previewBackend) {
-    return function getPreviewImageByCenterMiddleware (req, res, next) {
-        const width = +req.params.width;
-        const height = +req.params.height;
-        const zoom = +req.params.z;
-        const center = {
-            lng: +req.params.lng,
-            lat: +req.params.lat
-        };
-
-        const format = req.params.format === 'jpg' ? 'jpeg' : 'png';
-        const { mapConfigProvider: provider } = res.locals;
-
-        previewBackend.getImage(provider, format, width, height, zoom, center, (err, image, headers, stats = {}) => {
-            req.profiler.done(`render-${format}`);
-            req.profiler.add(stats);
-
-            if (err) {
-                err.label = 'STATIC_MAP';
-                return next(err);
-            }
-
-            if (headers) {
-                res.set(headers);
-            }
-
-            res.set('Content-Type', headers['Content-Type'] || `image/${format}`);
-
-            res.body = image;
-
-            next();
-        });
-    };
-}
-
-function getPreviewImageByBoundingBox (previewBackend) {
-    return function getPreviewImageByBoundingBoxMiddleware (req, res, next) {
-        const width = +req.params.width;
-        const height = +req.params.height;
-        const bounds = {
-            west: +req.params.west,
-            north: +req.params.north,
-            east: +req.params.east,
-            south: +req.params.south
-        };
-        const format = req.params.format === 'jpg' ? 'jpeg' : 'png';
-        const { mapConfigProvider: provider } = res.locals;
-
-        previewBackend.getImage(provider, format, width, height, bounds, (err, image, headers, stats = {}) => {
-            req.profiler.done(`render-${format}`);
-            req.profiler.add(stats);
-
-            if (err) {
-                err.label = 'STATIC_MAP';
-                return next(err);
-            }
-
-            if (headers) {
-                res.set(headers);
-            }
-
-            res.set('Content-Type', headers['Content-Type'] || `image/${format}`);
-
-            res.body = image;
-
-            next();
-        });
-    };
-}
-
-function setLastModifiedHeader () {
-    return function setLastModifiedHeaderMiddleware (req, res, next) {
-        let { cache_buster: cacheBuster } = res.locals;
-
-        cacheBuster = parseInt(cacheBuster, 10);
-
-        const lastUpdated = res.locals.cache_buster ? new Date(cacheBuster) : new Date();
-
-        res.set('Last-Modified', lastUpdated.toUTCString());
-
-        next();
-    };
-}
-
-function setCacheControlHeader () {
-    return function setCacheControlHeaderMiddleware (req, res, next) {
-        res.set('Cache-Control', 'public,max-age=31536000');
-
-        next();
-    };
-}
-
-function getAffectedTables (layergroupAffectedTables, pgConnection, mapStore) {
-    return function getAffectedTablesMiddleware (req, res, next) {
-        const { user, dbname, token } = res.locals;
-
-        if (layergroupAffectedTables.hasAffectedTables(dbname, token)) {
-            res.locals.affectedTables = layergroupAffectedTables.get(dbname, token);
-            return next();
+    var formatStat = 'invalid';
+    if (req.params.format) {
+        var format = req.params.format.replace('.', '_');
+        if (supportedFormats[format]) {
+            formatStat = format;
         }
+    }
 
-        mapStore.load(token, (err, mapconfig) => {
-            if (err) {
-                global.logger.warn('ERROR generating cache channel:', err);
-                return next();
-            }
-
-            const queries = [];
-            mapconfig.getLayers().forEach(function(layer) {
-                queries.push(layer.options.sql);
-                if (layer.options.affected_tables) {
-                    layer.options.affected_tables.map(function(table) {
-                        queries.push(`SELECT * FROM ${table} LIMIT 0`);
-                    });
-                }
-            });
-
-            const sql = queries.length ? queries.join(';') : null;
-
-            if (!sql) {
-                global.logger.warn('ERROR generating cache channel:' +
-                    ' this request doesn\'t need an X-Cache-Channel generated');
-                return next();
-            }
-
-            pgConnection.getConnection(user, (err, connection) => {
-                if (err) {
-                    global.logger.warn('ERROR generating cache channel:', err);
-                    return next();
-                }
-
-                QueryTables.getAffectedTablesFromQuery(connection, sql, (err, affectedTables) => {
-                    req.profiler.done('getAffectedTablesFromQuery');
-                    if (err) {
-                        global.logger.warn('ERROR generating cache channel: ', err);
-                        return next();
-                    }
-
-                    // feed affected tables cache so it can be reused from, for instance, map controller
-                    layergroupAffectedTables.set(dbname, token, affectedTables);
-
-                    res.locals.affectedTables = affectedTables;
-
-                    next();
-                });
-            });
-        });
-    };
-}
-
-function setCacheChannelHeader () {
-    return function setCacheChannelHeaderMiddleware (req, res, next) {
-        const { affectedTables } = res.locals;
-
-        if (affectedTables) {
-            res.set('X-Cache-Channel', affectedTables.getCacheChannel());
-        }
-
-        next();
-    };
-}
-
-function setSurrogateKeyHeader (surrogateKeysCache) {
-    return function setSurrogateKeyHeaderMiddleware (req, res, next) {
-        const { affectedTables } = res.locals;
-
-        if (affectedTables) {
-            surrogateKeysCache.tag(res, affectedTables);
-        }
-
-        next();
-    };
-}
-
-function incrementSuccessMetrics (statsClient) {
-    return function incrementSuccessMetricsMiddleware (req, res, next) {
-        const formatStat = parseFormat(req.params.format);
-
-        statsClient.increment('windshaft.tiles.success');
-        statsClient.increment(`windshaft.tiles.${formatStat}.success`);
-
-        next();
-    };
-}
-
-function sendResponse () {
-    return function sendResponseMiddleware (req, res) {
-        req.profiler.done('res');
-
-        res.status(res.statusCode || 200);
-
-        if (!Buffer.isBuffer(res.body) && typeof res.body === 'object') {
-            if (req.query && req.query.callback) {
-                res.jsonp(res.body);
-            } else {
-                res.json(res.body);
-            }
-        } else {
-            res.send(res.body);
-        }
-    };
-}
-
-function incrementErrorMetrics (statsClient) {
-    return function incrementErrorMetricsMiddleware (err, req, res, next) {
-        const formatStat = parseFormat(req.params.format);
-
-        statsClient.increment('windshaft.tiles.error');
-        statsClient.increment(`windshaft.tiles.${formatStat}.error`);
-
-        next(err);
-    };
-}
-
-function tileError () {
-    return function tileErrorMiddleware (err, req, res, next) {
+    if (err) {
         // See https://github.com/Vizzuality/Windshaft-cartodb/issues/68
-        let errMsg = err.message ? ( '' + err.message ) : ( '' + err );
+        var errMsg = err.message ? ( '' + err.message ) : ( '' + err );
 
         // Rewrite mapnik parsing errors to start with layer number
-        const matches = errMsg.match("(.*) in style 'layer([0-9]+)'");
-
+        var matches = errMsg.match("(.*) in style 'layer([0-9]+)'");
         if (matches) {
-            errMsg = `style${matches[2]}: ${matches[1]}`;
+            errMsg = 'style'+matches[2]+': ' + matches[1];
         }
-
         err.message = errMsg;
-        err.label = 'TILE RENDER';
 
+        err.label = 'TILE RENDER';
         next(err);
-    };
+
+        global.statsClient.increment('windshaft.tiles.error');
+        global.statsClient.increment('windshaft.tiles.' + formatStat + '.error');
+    } else {
+        this.sendResponse(req, res, tile, getStatusCode(tile, formatStat), headers);
+        global.statsClient.increment('windshaft.tiles.success');
+        global.statsClient.increment('windshaft.tiles.' + formatStat + '.success');
+    }
+};
+
+LayergroupController.prototype.bbox = function(req, res, next) {
+    this.staticMap(req, res, +req.params.width, +req.params.height, {
+        west: +req.params.west,
+        north: +req.params.north,
+        east: +req.params.east,
+        south: +req.params.south
+    }, null, next);
+};
+
+LayergroupController.prototype.center = function(req, res, next) {
+    this.staticMap(req, res, +req.params.width, +req.params.height, +req.params.z, {
+        lng: +req.params.lng,
+        lat: +req.params.lat
+    }, next);
+};
+
+LayergroupController.prototype.staticMap = function(req, res, width, height, zoom /* bounds */, center, next) {
+    var format = req.params.format === 'jpg' ? 'jpeg' : 'png';
+    // We force always the tile to be generated using PNG because
+    // is the only format we support by now
+    res.locals.format = 'png';
+    res.locals.layer = res.locals.layer || 'all';
+
+    var self = this;
+
+    step(
+        function getImage() {
+            if (center) {
+                self.previewBackend.getImage(
+                    new MapStoreMapConfigProvider(self.mapStore, res.locals.user, self.userLimitsApi, res.locals),
+                    format, width, height, zoom, center, this);
+            } else {
+                self.previewBackend.getImage(
+                    new MapStoreMapConfigProvider(self.mapStore, res.locals.user, self.userLimitsApi, res.locals),
+                    format, width, height, zoom /* bounds */, this);
+            }
+        },
+        function handleImage(err, image, headers, stats) {
+            req.profiler.done('render-' + format);
+            req.profiler.add(stats || {});
+
+            if (err) {
+                err.label = 'STATIC_MAP';
+                next(err);
+            } else {
+                res.set('Content-Type', headers['Content-Type'] || 'image/' + format);
+                self.sendResponse(req, res, image, 200);
+            }
+        }
+    );
+};
+
+LayergroupController.prototype.sendResponse = function(req, res, body, status, headers) {
+    var self = this;
+
+    req.profiler.done('res');
+
+    res.set('Cache-Control', 'public,max-age=31536000');
+
+    // Set Last-Modified header
+    var lastUpdated;
+    if (res.locals.cache_buster) {
+        // Assuming cache_buster is a timestamp
+        lastUpdated = new Date(parseInt(res.locals.cache_buster));
+    } else {
+        lastUpdated = new Date();
+    }
+    res.set('Last-Modified', lastUpdated.toUTCString());
+
+    var dbName = res.locals.dbname;
+    step(
+        function getAffectedTables() {
+            self.getAffectedTables(res.locals.user, dbName, res.locals.token, this);
+        },
+        function sendResponse(err, affectedTables) {
+            req.profiler.done('affectedTables');
+            if (err) {
+                global.logger.warn('ERROR generating cache channel: ' + err);
+            }
+            if (!!affectedTables) {
+                res.set('X-Cache-Channel', affectedTables.getCacheChannel());
+                self.surrogateKeysCache.tag(res, affectedTables);
+            }
+
+            if (headers) {
+                res.set(headers);
+            }
+
+            res.status(status);
+
+            if (!Buffer.isBuffer(body) && typeof body === 'object') {
+                if (req.query && req.query.callback) {
+                    res.jsonp(body);
+                } else {
+                    res.json(body);
+                }
+            } else {
+                res.send(body);
+            }
+        }
+    );
+};
+
+LayergroupController.prototype.getAffectedTables = function(user, dbName, layergroupId, callback) {
+
+    if (this.layergroupAffectedTables.hasAffectedTables(dbName, layergroupId)) {
+        return callback(null, this.layergroupAffectedTables.get(dbName, layergroupId));
+    }
+
+    var self = this;
+    step(
+        function extractSQL() {
+            step(
+                function loadFromStore() {
+                    self.mapStore.load(layergroupId, this);
+                },
+                function getSQL(err, mapConfig) {
+                    assert.ifError(err);
+
+                    var queries = [];
+                    mapConfig.getLayers().forEach(function(layer) {
+                        queries.push(layer.options.sql);
+                        if (layer.options.affected_tables) {
+                            layer.options.affected_tables.map(function(table) {
+                                queries.push('SELECT * FROM ' + table + ' LIMIT 0');
+                            });
+                        }
+                    });
+
+                    return queries.length ? queries.join(';') : null;
+                },
+                this
+            );
+        },
+        function findAffectedTables(err, sql) {
+            assert.ifError(err);
+
+            if ( ! sql ) {
+                throw new Error("this request doesn't need an X-Cache-Channel generated");
+            }
+
+            step(
+                function getConnection() {
+                    self.pgConnection.getConnection(user, this);
+                },
+                function getAffectedTables(err, connection) {
+                    assert.ifError(err);
+
+                    QueryTables.getAffectedTablesFromQuery(connection, sql, this);
+                },
+                this
+            );
+        },
+        function buildCacheChannel(err, tables) {
+            assert.ifError(err);
+            self.layergroupAffectedTables.set(dbName, layergroupId, tables);
+
+            return tables;
+        },
+        callback
+    );
+};
+
+
+function validateLayerRouteMiddleware(req, res, next) {
+    if (req.params.token === 'static') {
+        return next('route');
+    }
+
+    next();
 }

lib/cartodb/controllers/map.js

@@ -1,16 +1,20 @@
-const _ = require('underscore');
-const windshaft = require('windshaft');
-const MapConfig = windshaft.model.MapConfig;
-const Datasource = windshaft.model.Datasource;
-const QueryTables = require('cartodb-query-tables');
-const ResourceLocator = require('../models/resource-locator');
-const cors = require('../middleware/cors');
-const userMiddleware = require('../middleware/user');
+var _ = require('underscore');
+var windshaft = require('windshaft');
+var QueryTables = require('cartodb-query-tables');
+
+var ResourceLocator = require('../models/resource-locator');
+
+var cors = require('../middleware/cors');
+var userMiddleware = require('../middleware/user');
 const allowQueryParams = require('../middleware/allow-query-params');
-const NamedMapsCacheEntry = require('../cache/model/named_maps_entry');
-const NamedMapMapConfigProvider = require('../models/mapconfig/provider/named-map-provider');
-const CreateLayergroupMapConfigProvider = require('../models/mapconfig/provider/create-layergroup-provider');
-const LayergroupMetadata = require('../utils/layergroup-metadata');
+
+var MapConfig = windshaft.model.MapConfig;
+var Datasource = windshaft.model.Datasource;
+
+var NamedMapsCacheEntry = require('../cache/model/named_maps_entry');
+
+var NamedMapMapConfigProvider = require('../models/mapconfig/provider/named-map-provider');
+var CreateLayergroupMapConfigProvider = require('../models/mapconfig/provider/create-layergroup-provider');
 
 /**
  * @param {AuthApi} authApi
@@ -37,8 +41,7 @@ function MapController(prepareContext, pgConnection, templateMaps, mapBackend, m
     this.layergroupAffectedTables = layergroupAffectedTables;
 
     this.mapConfigAdapter = mapConfigAdapter;
-    const resourceLocator = new ResourceLocator(global.environment);
-    this.layergroupMetadata = new LayergroupMetadata(resourceLocator);
+    this.resourceLocator = new ResourceLocator(global.environment);
 
     this.statsBackend = statsBackend;
     this.prepareContext = prepareContext;
@@ -66,55 +69,35 @@ MapController.prototype.composeCreateMapMiddleware = function (useTemplate = fal
 
     return [
         cors(),
-        userMiddleware(),
+        userMiddleware,
         allowQueryParams(['aggregation']),
         this.prepareContext,
-        initProfiler(isTemplateInstantiation),
-        checkJsonContentType(),
-        this.getCreateMapMiddlewares(useTemplate),
-        incrementMapViewCount(this.metadataBackend),
-        augmentLayergroupData(),
-        getAffectedTables(this.pgConnection, this.layergroupAffectedTables),
-        setCacheChannel(),
-        setLastModified(),
-        setLastUpdatedTimeToLayergroup(),
-        setCacheControl(),
-        setLayerStats(this.pgConnection, this.statsBackend),
-        setLayergroupIdHeader(this.templateMaps ,useTemplateHash),
-        setDataviewsAndWidgetsUrlsToLayergroupMetadata(this.layergroupMetadata),
-        setAnalysesMetadataToLayergroup(this.layergroupMetadata, includeQuery),
-        setTurboCartoMetadataToLayergroup(this.layergroupMetadata),
-        setAggregationMetadataToLayergroup(this.layergroupMetadata),
-        setTilejsonMetadataToLayergroup(this.layergroupMetadata),
-        setSurrogateKeyHeader(this.surrogateKeysCache),
-        sendResponse(),
-        augmentError({ label, addContext })
+        this.initProfiler(isTemplateInstantiation),
+        this.checkJsonContentType(),
+        useTemplate ? this.checkInstantiteLayergroup() : this.checkCreateLayergroup(),
+        useTemplate ? this.getTemplate() : this.prepareAdapterMapConfig(),
+        useTemplate ? this.instantiateLayergroup() : this.createLayergroup(),
+        this.incrementMapViewCount(),
+        this.augmentLayergroupData(),
+        this.getAffectedTables(),
+        this.setCacheChannel(),
+        this.setLastModified(),
+        this.setLastUpdatedTimeToLayergroup(),
+        this.setCacheControl(),
+        this.setLayerStats(),
+        this.setLayergroupIdHeader(useTemplateHash),
+        this.setDataviewsAndWidgetsUrlsToLayergroupMetadata(),
+        this.setAnalysesMetadataToLayergroup(includeQuery),
+        this.setTurboCartoMetadataToLayergroup(),
+        this.setAggregationMetadataToLayergroup(),
+        this.setTilejsonMetadataToLayergroup(),
+        this.setSurrogateKeyHeader(),
+        this.sendResponse(),
+        this.augmentError({ label, addContext })
     ];
 };
 
-MapController.prototype.getCreateMapMiddlewares = function (useTemplate) {
-    if (useTemplate) {
-        return [
-            checkInstantiteLayergroup(),
-            getTemplate(
-                this.templateMaps,
-                this.pgConnection,
-                this.metadataBackend,
-                this.userLimitsApi,
-                this.mapConfigAdapter
-            ),
-            instantiateLayergroup(this.mapBackend, this.userLimitsApi)
-        ];
-    }
-
-    return [
-        checkCreateLayergroup(),
-        prepareAdapterMapConfig(this.mapConfigAdapter),
-        createLayergroup (this.mapBackend, this.userLimitsApi)
-    ];
-};
-
-function initProfiler (isTemplateInstantiation) {
+MapController.prototype.initProfiler = function (isTemplateInstantiation) {
     const operation = isTemplateInstantiation ? 'instance_template' : 'createmap';
 
     return function initProfilerMiddleware (req, res, next) {
@@ -122,9 +105,9 @@ function initProfiler (isTemplateInstantiation) {
         req.profiler.done(`${operation}.initProfilerMiddleware`);
         next();
     };
-}
+};
 
-function checkJsonContentType () {
+MapController.prototype.checkJsonContentType = function () {
     return function checkJsonContentTypeMiddleware(req, res, next) {
         if (req.method === 'POST' && !req.is('application/json')) {
             return next(new Error('POST data must be of type application/json'));
@@ -134,9 +117,9 @@ function checkJsonContentType () {
 
         next();
     };
-}
+};
 
-function checkInstantiteLayergroup () {
+MapController.prototype.checkInstantiteLayergroup = function () {
     return function checkInstantiteLayergroupMiddleware(req, res, next) {
         if (req.method === 'GET') {
             const { callback, config } = req.query;
@@ -158,9 +141,9 @@ function checkInstantiteLayergroup () {
 
         return next();
     };
-}
+};
 
-function checkCreateLayergroup () {
+MapController.prototype.checkCreateLayergroup = function () {
     return function checkCreateLayergroupMiddleware (req, res, next) {
         if (req.method === 'GET') {
             const { config } = res.locals;
@@ -179,19 +162,19 @@ function checkCreateLayergroup () {
         req.profiler.done('checkCreateLayergroup');
         return next();
     };
-}
+};
 
-function getTemplate (templateMaps, pgConnection, metadataBackend, userLimitsApi, mapConfigAdapter) {
+MapController.prototype.getTemplate = function () {
     return function getTemplateMiddleware (req, res, next) {
         const templateParams = req.body;
         const { user } = res.locals;
 
         const mapconfigProvider = new NamedMapMapConfigProvider(
-            templateMaps,
-            pgConnection,
-            metadataBackend,
-            userLimitsApi,
-            mapConfigAdapter,
+            this.templateMaps,
+            this.pgConnection,
+            this.metadataBackend,
+            this.userLimitsApi,
+            this.mapConfigAdapter,
             user,
             req.params.template_id,
             templateParams,
@@ -211,10 +194,10 @@ function getTemplate (templateMaps, pgConnection, metadataBackend, userLimitsApi
 
             next();
         });
-    };
-}
+    }.bind(this);
+};
 
-function prepareAdapterMapConfig (mapConfigAdapter) {
+MapController.prototype.prepareAdapterMapConfig = function () {
     return function prepareAdapterMapConfigMiddleware(req, res, next) {
         const requestMapConfig = req.body;
         const { user, dbhost, dbport, dbname, dbuser, dbpassword, api_key } = res.locals;
@@ -236,7 +219,7 @@ function prepareAdapterMapConfig (mapConfigAdapter) {
             }
         };
 
-        mapConfigAdapter.getMapConfig(user, requestMapConfig, res.locals, context, (err, requestMapConfig) => {
+        this.mapConfigAdapter.getMapConfig(user, requestMapConfig, res.locals, context, (err, requestMapConfig) => {
             req.profiler.done('anonymous.getMapConfig');
             if (err) {
                 return next(err);
@@ -247,22 +230,22 @@ function prepareAdapterMapConfig (mapConfigAdapter) {
 
             next();
         });
-    };
-}
+    }.bind(this);
+};
 
-function createLayergroup (mapBackend, userLimitsApi) {
+MapController.prototype.createLayergroup = function () {
     return function createLayergroupMiddleware (req, res, next) {
         const requestMapConfig = req.body;
         const { context, user } = res.locals;
         const datasource = context.datasource || Datasource.EmptyDatasource();
         const mapconfig = new MapConfig(requestMapConfig, datasource);
         const mapconfigProvider =
-            new CreateLayergroupMapConfigProvider(mapconfig, user, userLimitsApi, res.locals);
+            new CreateLayergroupMapConfigProvider(mapconfig, user, this.userLimitsApi, res.locals);
 
         res.locals.mapconfig = mapconfig;
         res.locals.analysesResults = context.analysesResults;
 
-        mapBackend.createLayergroup(mapconfig, res.locals, mapconfigProvider, (err, layergroup) => {
+        this.mapBackend.createLayergroup(mapconfig, res.locals, mapconfigProvider, (err, layergroup) => {
             req.profiler.done('createLayergroup');
             if (err) {
                 return next(err);
@@ -272,16 +255,16 @@ function createLayergroup (mapBackend, userLimitsApi) {
 
             next();
         });
-    };
-}
+    }.bind(this);
+};
 
-function instantiateLayergroup (mapBackend, userLimitsApi) {
+MapController.prototype.instantiateLayergroup = function () {
     return function instantiateLayergroupMiddleware (req, res, next) {
         const { user, mapconfig, rendererParams } = res.locals;
         const mapconfigProvider =
-            new CreateLayergroupMapConfigProvider(mapconfig, user, userLimitsApi, rendererParams);
+            new CreateLayergroupMapConfigProvider(mapconfig, user, this.userLimitsApi, rendererParams);
 
-        mapBackend.createLayergroup(mapconfig, rendererParams, mapconfigProvider, (err, layergroup) => {
+        this.mapBackend.createLayergroup(mapconfig, rendererParams, mapconfigProvider, (err, layergroup) => {
             req.profiler.done('createLayergroup');
             if (err) {
                 return next(err);
@@ -298,15 +281,15 @@ function instantiateLayergroup (mapBackend, userLimitsApi) {
 
             next();
         });
-    };
-}
+    }.bind(this);
+};
 
-function incrementMapViewCount (metadataBackend) {
+MapController.prototype.incrementMapViewCount = function () {
     return function incrementMapViewCountMiddleware(req, res, next) {
         const { mapconfig, user } = res.locals;
 
         // Error won't blow up, just be logged.
-        metadataBackend.incMapviewCount(user, mapconfig.obj().stat_tag, (err) => {
+        this.metadataBackend.incMapviewCount(user, mapconfig.obj().stat_tag, (err) => {
             req.profiler.done('incMapviewCount');
 
             if (err) {
@@ -315,10 +298,10 @@ function incrementMapViewCount (metadataBackend) {
 
             next();
         });
-    };
-}
+    }.bind(this);
+};
 
-function augmentLayergroupData () {
+MapController.prototype.augmentLayergroupData = function () {
     return function augmentLayergroupDataMiddleware (req, res, next) {
         const { layergroup } = res.locals;
 
@@ -329,13 +312,91 @@ function augmentLayergroupData () {
 
         next();
     };
+};
+
+function getTemplateUrl(url) {
+    return url.https || url.http;
 }
 
-function getAffectedTables (pgConnection, layergroupAffectedTables) {
+function getTilejson(tiles, grids) {
+    const tilejson = {
+        tilejson: '2.2.0',
+        tiles: tiles.https || tiles.http
+    };
+
+    if (grids) {
+        tilejson.grids = grids.https || grids.http;
+    }
+
+    return tilejson;
+}
+
+MapController.prototype.setTilejsonMetadataToLayergroup = function () {
+    return function augmentLayergroupTilejsonMiddleware (req, res, next) {
+        const { layergroup, user, mapconfig } = res.locals;
+
+        const isVectorOnlyMapConfig = mapconfig.isVectorOnlyMapConfig();
+        let hasMapnikLayers = false;
+        layergroup.metadata.layers.forEach((layerMetadata, index) => {
+            const layerId = mapconfig.getLayerId(index);
+            const rasterResource = `${layergroup.layergroupid}/${layerId}/{z}/{x}/{y}.png`;
+            if (mapconfig.layerType(index) === 'mapnik') {
+                hasMapnikLayers = true;
+                const vectorResource = `${layergroup.layergroupid}/${layerId}/{z}/{x}/{y}.mvt`;
+                const layerTilejson = {
+                    vector: getTilejson(this.resourceLocator.getTileUrls(user, vectorResource))
+                };
+                if (!isVectorOnlyMapConfig) {
+                    let grids = null;
+                    const layer = mapconfig.getLayer(index);
+                    if (layer.options.interactivity) {
+                        const gridResource = `${layergroup.layergroupid}/${layerId}/{z}/{x}/{y}.grid.json`;
+                        grids = this.resourceLocator.getTileUrls(user, gridResource);
+                    }
+                    layerTilejson.raster = getTilejson(
+                        this.resourceLocator.getTileUrls(user, rasterResource),
+                        grids
+                    );
+                }
+                layerMetadata.tilejson = layerTilejson;
+            } else {
+                layerMetadata.tilejson = {
+                    raster: getTilejson(this.resourceLocator.getTileUrls(user, rasterResource))
+                };
+            }
+        });
+
+        const tilejson = {};
+        const url = {};
+
+        if (hasMapnikLayers) {
+            const vectorResource = `${layergroup.layergroupid}/{z}/{x}/{y}.mvt`;
+            tilejson.vector = getTilejson(
+                this.resourceLocator.getTileUrls(user, vectorResource)
+            );
+            url.vector = getTemplateUrl(this.resourceLocator.getTemplateUrls(user, vectorResource));
+
+            if (!isVectorOnlyMapConfig) {
+                const rasterResource = `${layergroup.layergroupid}/{z}/{x}/{y}.png`;
+                tilejson.raster = getTilejson(
+                    this.resourceLocator.getTileUrls(user, rasterResource)
+                );
+                url.raster = getTemplateUrl(this.resourceLocator.getTemplateUrls(user, rasterResource));
+            }
+        }
+
+        layergroup.metadata.tilejson = tilejson;
+        layergroup.metadata.url = url;
+
+        next();
+    }.bind(this);
+};
+
+MapController.prototype.getAffectedTables = function () {
     return function getAffectedTablesMiddleware (req, res, next) {
         const { dbname, layergroup, user, mapconfig } = res.locals;
 
-        pgConnection.getConnection(user, (err, connection) => {
+        this.pgConnection.getConnection(user, (err, connection) => {
             if (err) {
                 return next(err);
             }
@@ -357,17 +418,17 @@ function getAffectedTables (pgConnection, layergroupAffectedTables) {
                 }
 
                 // feed affected tables cache so it can be reused from, for instance, layergroup controller
-                layergroupAffectedTables.set(dbname, layergroup.layergroupId, affectedTables);
+                this.layergroupAffectedTables.set(dbname, layergroup.layergroupId, affectedTables);
 
                 res.locals.affectedTables = affectedTables;
 
                 next();
             });
         });
-    };
-}
+    }.bind(this);
+};
 
-function setCacheChannel () {
+MapController.prototype.setCacheChannel = function () {
     return function setCacheChannelMiddleware (req, res, next) {
         const { affectedTables } = res.locals;
 
@@ -377,9 +438,9 @@ function setCacheChannel () {
 
         next();
     };
-}
+};
 
-function setLastModified () {
+MapController.prototype.setLastModified = function () {
     return function setLastModifiedMiddleware (req, res, next) {
         if (req.method === 'GET') {
             res.set('Last-Modified', (new Date()).toUTCString());
@@ -387,9 +448,9 @@ function setLastModified () {
 
         next();
     };
-}
+};
 
-function setLastUpdatedTimeToLayergroup () {
+MapController.prototype.setLastUpdatedTimeToLayergroup = function () {
     return function setLastUpdatedTimeToLayergroupMiddleware (req, res, next) {
         const { affectedTables, layergroup, analysesResults } = res.locals;
 
@@ -403,7 +464,7 @@ function setLastUpdatedTimeToLayergroup () {
 
         next();
     };
-}
+};
 
 function getLastUpdatedTime(analysesResults, lastUpdateTime) {
     if (!Array.isArray(analysesResults)) {
@@ -418,7 +479,7 @@ function getLastUpdatedTime(analysesResults, lastUpdateTime) {
     }, lastUpdateTime);
 }
 
-function setCacheControl () {
+MapController.prototype.setCacheControl = function () {
     return function setCacheControlMiddleware (req, res, next) {
         if (req.method === 'GET') {
             var ttl = global.environment.varnish.layergroupTtl || 86400;
@@ -427,18 +488,18 @@ function setCacheControl () {
 
         next();
     };
-}
+};
 
-function setLayerStats (pgConnection, statsBackend) {
+MapController.prototype.setLayerStats = function () {
     return function setLayerStatsMiddleware(req, res, next) {
         const { user, mapconfig, layergroup } = res.locals;
 
-        pgConnection.getConnection(user, (err, connection) => {
+        this.pgConnection.getConnection(user, (err, connection) => {
             if (err) {
                 return next(err);
             }
 
-            statsBackend.getStats(mapconfig, connection, function(err, layersStats) {
+            this.statsBackend.getStats(mapconfig, connection, function(err, layersStats) {
                 if (err) {
                     return next(err);
                 }
@@ -452,91 +513,171 @@ function setLayerStats (pgConnection, statsBackend) {
                 next();
             });
         });
-    };
-}
+    }.bind(this);
+};
 
-function setLayergroupIdHeader (templateMaps, useTemplateHash) {
+MapController.prototype.setLayergroupIdHeader = function (useTemplateHash) {
     return function setLayergroupIdHeaderMiddleware (req, res, next) {
         const { layergroup, user, template } = res.locals;
 
         if (useTemplateHash) {
-            var templateHash = templateMaps.fingerPrint(template).substring(0, 8);
+            var templateHash = this.templateMaps.fingerPrint(template).substring(0, 8);
             layergroup.layergroupid = `${user}@${templateHash}@${layergroup.layergroupid}`;
         }
 
         res.set('X-Layergroup-Id', layergroup.layergroupid);
 
         next();
-    };
-}
+    }.bind(this);
+};
 
-function setDataviewsAndWidgetsUrlsToLayergroupMetadata (layergroupMetadata) {
+MapController.prototype.setDataviewsAndWidgetsUrlsToLayergroupMetadata = function () {
     return function setDataviewsAndWidgetsUrlsToLayergroupMetadataMiddleware (req, res, next) {
         const { layergroup, user, mapconfig } = res.locals;
 
-        layergroupMetadata.addDataviewsAndWidgetsUrls(user, layergroup, mapconfig.obj());
+        this.addDataviewsAndWidgetsUrls(user, layergroup, mapconfig.obj());
 
         next();
-    };
-}
+    }.bind(this);
+};
 
-function setAnalysesMetadataToLayergroup (layergroupMetadata, includeQuery) {
+// TODO this should take into account several URL patterns
+MapController.prototype.addDataviewsAndWidgetsUrls = function(username, layergroup, mapConfig) {
+    this.addDataviewsUrls(username, layergroup, mapConfig);
+    this.addWidgetsUrl(username, layergroup, mapConfig);
+};
+
+MapController.prototype.addDataviewsUrls = function(username, layergroup, mapConfig) {
+    layergroup.metadata.dataviews = layergroup.metadata.dataviews || {};
+    var dataviews = mapConfig.dataviews || {};
+
+    Object.keys(dataviews).forEach(function(dataviewName) {
+        var resource = layergroup.layergroupid + '/dataview/' + dataviewName;
+        layergroup.metadata.dataviews[dataviewName] = {
+            url: this.resourceLocator.getUrls(username, resource)
+        };
+    }.bind(this));
+};
+
+MapController.prototype.addWidgetsUrl = function(username, layergroup, mapConfig) {
+    if (layergroup.metadata && Array.isArray(layergroup.metadata.layers) && Array.isArray(mapConfig.layers)) {
+        layergroup.metadata.layers = layergroup.metadata.layers.map(function(layer, layerIndex) {
+            var mapConfigLayer = mapConfig.layers[layerIndex];
+            if (mapConfigLayer.options && mapConfigLayer.options.widgets) {
+                layer.widgets = layer.widgets || {};
+                Object.keys(mapConfigLayer.options.widgets).forEach(function(widgetName) {
+                    var resource = layergroup.layergroupid + '/' + layerIndex + '/widget/' + widgetName;
+                    layer.widgets[widgetName] = {
+                        type: mapConfigLayer.options.widgets[widgetName].type,
+                        url: this.resourceLocator.getUrls(username, resource)
+                    };
+                }.bind(this));
+            }
+            return layer;
+        }.bind(this));
+    }
+};
+
+MapController.prototype.setAnalysesMetadataToLayergroup = function (includeQuery) {
     return function setAnalysesMetadataToLayergroupMiddleware (req, res, next) {
         const { layergroup, user, analysesResults = [] } = res.locals;
 
-        layergroupMetadata.addAnalysesMetadata(user, layergroup, analysesResults, includeQuery);
+        this.addAnalysesMetadata(user, layergroup, analysesResults, includeQuery);
 
         next();
-    };
-}
+    }.bind(this);
+};
 
-function setTurboCartoMetadataToLayergroup (layergroupMetadata) {
+MapController.prototype.addAnalysesMetadata = function(username, layergroup, analysesResults, includeQuery) {
+    includeQuery = includeQuery || false;
+    analysesResults = analysesResults || [];
+    layergroup.metadata.analyses = [];
+
+    analysesResults.forEach(function(analysis) {
+        var nodes = analysis.getNodes();
+        layergroup.metadata.analyses.push({
+            nodes: nodes.reduce(function(nodesIdMap, node) {
+                if (node.params.id) {
+                    var nodeResource = layergroup.layergroupid + '/analysis/node/' + node.id();
+                    var nodeRepr = {
+                        status: node.getStatus(),
+                        url: this.resourceLocator.getUrls(username, nodeResource)
+                    };
+                    if (includeQuery) {
+                        nodeRepr.query = node.getQuery();
+                    }
+                    if (node.getStatus() === 'failed') {
+                        nodeRepr.error_message = node.getErrorMessage();
+                    }
+                    nodesIdMap[node.params.id] = nodeRepr;
+                }
+
+                return nodesIdMap;
+            }.bind(this), {})
+        });
+    }.bind(this));
+};
+
+MapController.prototype.setTurboCartoMetadataToLayergroup = function () {
     return function setTurboCartoMetadataToLayergroupMiddleware (req, res, next) {
         const { layergroup, mapconfig, context } = res.locals;
 
-        layergroupMetadata.addTurboCartoContextMetadata(layergroup, mapconfig.obj(), context);
+        addTurboCartoContextMetadata(layergroup, mapconfig.obj(), context);
 
         next();
     };
+};
+
+function addTurboCartoContextMetadata(layergroup, mapConfig, context) {
+    if (layergroup.metadata && Array.isArray(layergroup.metadata.layers) && Array.isArray(mapConfig.layers)) {
+        layergroup.metadata.layers = layergroup.metadata.layers.map(function(layer, layerIndex) {
+            if (context.turboCarto && Array.isArray(context.turboCarto.layers)) {
+                layer.meta.cartocss_meta = context.turboCarto.layers[layerIndex];
+            }
+            return layer;
+        });
+    }
 }
 
-function setAggregationMetadataToLayergroup (layergroupMetadata) {
+// TODO: see how evolve this function, it's a good candidate to be refactored
+MapController.prototype.setAggregationMetadataToLayergroup = function () {
     return function setAggregationMetadataToLayergroupMiddleware (req, res, next) {
         const { layergroup, mapconfig, context } = res.locals;
 
-        layergroupMetadata.addAggregationContextMetadata(layergroup, mapconfig.obj(), context);
+        addAggregationContextMetadata(layergroup, mapconfig.obj(), context);
 
         next();
     };
+};
+
+function addAggregationContextMetadata(layergroup, mapConfig, context) {
+    if (layergroup.metadata && Array.isArray(layergroup.metadata.layers) && Array.isArray(mapConfig.layers)) {
+        layergroup.metadata.layers = layergroup.metadata.layers.map(function(layer, layerIndex) {
+            if (context.aggregation && Array.isArray(context.aggregation.layers)) {
+                layer.meta.aggregation = context.aggregation.layers[layerIndex];
+            }
+            return layer;
+        });
+    }
 }
 
-function setTilejsonMetadataToLayergroup (layergroupMetadata) {
-    return function augmentLayergroupTilejsonMiddleware (req, res, next) {
-        const { layergroup, user, mapconfig } = res.locals;
-
-        layergroupMetadata.addTileJsonMetadata(layergroup, user, mapconfig);
-
-        next();
-    };
-}
-
-function setSurrogateKeyHeader (surrogateKeysCache) {
+MapController.prototype.setSurrogateKeyHeader = function () {
     return function setSurrogateKeyHeaderMiddleware(req, res, next) {
         const { affectedTables, user, templateName } = res.locals;
 
         if (req.method === 'GET' && affectedTables.tables && affectedTables.tables.length > 0) {
-            surrogateKeysCache.tag(res, affectedTables);
+            this.surrogateKeysCache.tag(res, affectedTables);
         }
 
         if (templateName) {
-            surrogateKeysCache.tag(res, new NamedMapsCacheEntry(user, templateName));
+            this.surrogateKeysCache.tag(res, new NamedMapsCacheEntry(user, templateName));
         }
 
         next();
-    };
-}
+    }.bind(this);
+};
 
-function sendResponse () {
+MapController.prototype.sendResponse = function () {
     return function sendResponseMiddleware (req, res) {
         req.profiler.done('res');
         const { layergroup } = res.locals;
@@ -549,9 +690,9 @@ function sendResponse () {
             res.json(layergroup);
         }
     };
-}
+};
 
-function augmentError (options) {
+MapController.prototype.augmentError = function (options) {
     const { addContext = false, label = 'MAPS CONTROLLER' } = options;
 
     return function augmentErrorMiddleware (err, req, res, next) {
@@ -566,7 +707,7 @@ function augmentError (options) {
 
         next(err);
     };
-}
+};
 
 function populateError(err, mapConfig) {
     var error = new Error(err.message);

lib/cartodb/controllers/named_maps.js

@@ -41,73 +41,59 @@ function NamedMapsController(prepareContext, namedMapProviderCache, tileBackend,
 module.exports = NamedMapsController;
 
 NamedMapsController.prototype.register = function(app) {
-    const { base_url_mapconfig, base_url_templated } = app;
-
     app.get(
-        `${base_url_templated}/:template_id/:layer/:z/:x/:y.(:format)`,
+        app.base_url_templated + '/:template_id/:layer/:z/:x/:y.(:format)',
         cors(),
-        userMiddleware(),
+        userMiddleware,
         this.prepareContext,
-        getNamedMapProvider({
-            namedMapProviderCache: this.namedMapProviderCache,
-            label: 'NAMED_MAP_TILE'
-        }),
-        getAffectedTables(),
-        getTile({
-            tileBackend: this.tileBackend,
-            label: 'NAMED_MAP_TILE'
-        }),
-        setSurrogateKeyHeader({ surrogateKeysCache: this.surrogateKeysCache }),
-        setCacheChannelHeader(),
-        setLastModifiedHeader(),
-        setCacheControlHeader(),
-        setContentTypeHeader(),
-        sendResponse(),
+        this.getNamedMapProvider('NAMED_MAP_TILE'),
+        this.getAffectedTables(),
+        this.getTile('NAMED_MAP_TILE'),
+        this.setSurrogateKey(),
+        this.setCacheChannelHeader(),
+        this.setLastModifiedHeader(),
+        this.setCacheControlHeader(),
+        this.setContentTypeHeader(),
+        this.respond(),
         vectorError()
     );
 
     app.get(
-        `${base_url_mapconfig}/static/named/:template_id/:width/:height.:format`,
+        app.base_url_mapconfig + '/static/named/:template_id/:width/:height.:format',
         cors(),
-        userMiddleware(),
+        userMiddleware,
         allowQueryParams(['layer', 'zoom', 'lon', 'lat', 'bbox']),
         this.prepareContext,
-        getNamedMapProvider({
-            namedMapProviderCache: this.namedMapProviderCache,
-            label: 'STATIC_VIZ_MAP', forcedFormat: 'png'
-        }),
-        getAffectedTables(),
-        getTemplate({ label: 'STATIC_VIZ_MAP' }),
-        prepareLayerFilterFromPreviewLayers({
-            namedMapProviderCache: this.namedMapProviderCache,
-            label: 'STATIC_VIZ_MAP'
-        }),
-        getStaticImageOptions({ tablesExtentApi: this.tablesExtentApi }),
-        getImage({ previewBackend: this.previewBackend, label: 'STATIC_VIZ_MAP' }),
-        incrementMapViews({ metadataBackend: this.metadataBackend }),
-        setSurrogateKeyHeader({ surrogateKeysCache: this.surrogateKeysCache }),
-        setCacheChannelHeader(),
-        setLastModifiedHeader(),
-        setCacheControlHeader(),
-        setContentTypeHeader(),
-        sendResponse()
+        this.getNamedMapProvider('STATIC_VIZ_MAP'),
+        this.getAffectedTables(),
+        this.getTemplate('STATIC_VIZ_MAP'),
+        this.prepareLayerFilterFromPreviewLayers('STATIC_VIZ_MAP'),
+        this.getStaticImageOptions(),
+        this.getImage('STATIC_VIZ_MAP'),
+        this.incrementMapViews(),
+        this.setSurrogateKey(),
+        this.setCacheChannelHeader(),
+        this.setLastModifiedHeader(),
+        this.setCacheControlHeader(),
+        this.setContentTypeHeader(),
+        this.respond()
     );
 };
 
-function getNamedMapProvider ({ namedMapProviderCache, label, forcedFormat = null }) {
+NamedMapsController.prototype.getNamedMapProvider = function (label) {
     return function getNamedMapProviderMiddleware (req, res, next) {
         const { user } = res.locals;
         const { config, auth_token } = req.query;
         const { template_id } = req.params;
 
-        if (forcedFormat) {
-            res.locals.format = forcedFormat;
-            res.locals.layer = res.locals.layer || 'all';
-        }
+        // We force always the tile to be generated using PNG because
+        // is the only format we support by now
+        res.locals.format = 'png';
+        res.locals.layer = res.locals.layer || 'all';
 
         const params = getRequestParams(res.locals);
 
-        namedMapProviderCache.get(user, template_id, config, auth_token, params, (err, namedMapProvider) => {
+        this.namedMapProviderCache.get(user, template_id, config, auth_token, params, (err, namedMapProvider) => {
             if (err) {
                 err.label = label;
                 return next(err);
@@ -117,10 +103,10 @@ function getNamedMapProvider ({ namedMapProviderCache, label, forcedFormat = nul
 
             next();
         });
-    };
-}
+    }.bind(this);
+};
 
-function getAffectedTables () {
+NamedMapsController.prototype.getAffectedTables = function () {
     return function getAffectedTables (req, res, next) {
         const { namedMapProvider } = res.locals;
 
@@ -135,10 +121,10 @@ function getAffectedTables () {
 
             next();
         });
-    };
-}
+    }.bind(this);
+};
 
-function getTemplate ({ label }) {
+NamedMapsController.prototype.getTemplate = function (label) {
     return function getTemplateMiddleware (req, res, next) {
         const { namedMapProvider } = res.locals;
 
@@ -153,9 +139,9 @@ function getTemplate ({ label }) {
             next();
         });
     };
-}
+};
 
-function prepareLayerFilterFromPreviewLayers ({ namedMapProviderCache, label }) {
+NamedMapsController.prototype.prepareLayerFilterFromPreviewLayers = function (label) {
     return function prepareLayerFilterFromPreviewLayersMiddleware (req, res, next) {
         const { user, template } = res.locals;
         const { template_id } = req.params;
@@ -184,7 +170,7 @@ function prepareLayerFilterFromPreviewLayers ({ namedMapProviderCache, label })
         params.layer = layerVisibilityFilter.join(',');
 
         // recreates the provider
-        namedMapProviderCache.get(user, template_id, config, auth_token, params, (err, provider) => {
+        this.namedMapProviderCache.get(user, template_id, config, auth_token, params, (err, provider) => {
             if (err) {
                 err.label = label;
                 return next(err);
@@ -194,14 +180,14 @@ function prepareLayerFilterFromPreviewLayers ({ namedMapProviderCache, label })
 
             next();
         });
-    };
-}
+    }.bind(this);
+};
 
-function getTile ({ tileBackend, label }) {
+NamedMapsController.prototype.getTile = function (label) {
     return function getTileMiddleware (req, res, next) {
         const { namedMapProvider } = res.locals;
 
-        tileBackend.getTile(namedMapProvider, req.params, (err, tile, headers, stats) => {
+        this.tileBackend.getTile(namedMapProvider, req.params, (err, tile, headers, stats) => {
             req.profiler.add(stats);
 
             if (err) {
@@ -215,10 +201,10 @@ function getTile ({ tileBackend, label }) {
 
             next();
         });
-    };
-}
+    }.bind(this);
+};
 
-function getStaticImageOptions ({ tablesExtentApi }) {
+NamedMapsController.prototype.getStaticImageOptions = function () {
     return function getStaticImageOptionsMiddleware(req, res, next) {
         const { user, namedMapProvider, template } = res.locals;
 
@@ -242,7 +228,7 @@ function getStaticImageOptions ({ tablesExtentApi }) {
                 return next();
             }
 
-            tablesExtentApi.getBounds(user, affectedTables, (err, bounds) => {
+            this.tablesExtentApi.getBounds(user, affectedTables, (err, bounds) => {
                 if (err) {
                     return next();
                 }
@@ -252,8 +238,8 @@ function getStaticImageOptions ({ tablesExtentApi }) {
                 return next();
             });
         });
-    };
-}
+    }.bind(this);
+};
 
 function getImageOptions (params, template) {
     const { zoom, lon, lat, bbox } = params;
@@ -320,7 +306,7 @@ function getImageOptionsFromBoundingBox (bbox = '') {
     }
 }
 
-function getImage({ previewBackend, label }) {
+NamedMapsController.prototype.getImage = function (label) {
     return function getImageMiddleware (req, res, next) {
         const { imageOpts, namedMapProvider } = res.locals;
         const { zoom, center, bounds } = imageOpts;
@@ -333,7 +319,7 @@ function getImage({ previewBackend, label }) {
         const format = req.params.format === 'jpg' ? 'jpeg' : 'png';
 
         if (zoom !== undefined && center) {
-            return previewBackend.getImage(namedMapProvider, format, width, height, zoom, center,
+            return this.previewBackend.getImage(namedMapProvider, format, width, height, zoom, center,
                 (err, image, headers, stats) => {
                 if (err) {
                     err.label = label;
@@ -348,7 +334,7 @@ function getImage({ previewBackend, label }) {
             });
         }
 
-        previewBackend.getImage(namedMapProvider, format, width, height, bounds, (err, image, headers, stats) => {
+        this.previewBackend.getImage(namedMapProvider, format, width, height, bounds, (err, image, headers, stats) => {
             if (err) {
                 err.label = label;
                 return next(err);
@@ -360,14 +346,14 @@ function getImage({ previewBackend, label }) {
 
             next();
         });
-    };
-}
+    }.bind(this);
+};
 
 function incrementMapViewsError (ctx) {
     return `ERROR: failed to increment mapview count for user '${ctx.user}': ${ctx.err}`;
 }
 
-function incrementMapViews ({ metadataBackend }) {
+NamedMapsController.prototype.incrementMapViews = function () {
     return function incrementMapViewsMiddleware(req, res, next) {
         const { user, namedMapProvider } = res.locals;
 
@@ -379,7 +365,7 @@ function incrementMapViews ({ metadataBackend }) {
 
             const statTag = mapConfig.obj().stat_tag;
 
-            metadataBackend.incMapviewCount(user, statTag, (err) => {
+            this.metadataBackend.incMapviewCount(user, statTag, (err) => {
                 if (err) {
                     global.logger.log(incrementMapViewsError({ user, err }));
                 }
@@ -387,8 +373,8 @@ function incrementMapViews ({ metadataBackend }) {
                 next();
             });
         });
-    };
-}
+    }.bind(this);
+};
 
 function templateZoomCenter(view) {
     if (view.zoom !== undefined && view.center) {
@@ -420,22 +406,7 @@ function templateBounds(view) {
     return false;
 }
 
-function setSurrogateKeyHeader ({ surrogateKeysCache }) {
-    return function setSurrogateKeyHeaderMiddleware(req, res, next) {
-        const { user, namedMapProvider, affectedTablesAndLastUpdate } = res.locals;
-
-        surrogateKeysCache.tag(res, new NamedMapsCacheEntry(user, namedMapProvider.getTemplateName()));
-        if (!affectedTablesAndLastUpdate || !!affectedTablesAndLastUpdate.tables) {
-            if (affectedTablesAndLastUpdate.tables.length > 0) {
-                surrogateKeysCache.tag(res, affectedTablesAndLastUpdate);
-            }
-        }
-
-        next();
-    };
-}
-
-function setCacheChannelHeader () {
+NamedMapsController.prototype.setCacheChannelHeader = function () {
     return function setCacheChannelHeaderMiddleware (req, res, next) {
         const { affectedTablesAndLastUpdate } = res.locals;
 
@@ -445,9 +416,24 @@ function setCacheChannelHeader () {
 
         next();
     };
-}
+};
 
-function setLastModifiedHeader () {
+NamedMapsController.prototype.setSurrogateKey = function () {
+    return function setSurrogateKeyMiddleware(req, res, next) {
+        const { user, namedMapProvider, affectedTablesAndLastUpdate } = res.locals;
+
+        this.surrogateKeysCache.tag(res, new NamedMapsCacheEntry(user, namedMapProvider.getTemplateName()));
+        if (!affectedTablesAndLastUpdate || !!affectedTablesAndLastUpdate.tables) {
+            if (affectedTablesAndLastUpdate.tables.length > 0) {
+                this.surrogateKeysCache.tag(res, affectedTablesAndLastUpdate);
+            }
+        }
+
+        next();
+    }.bind(this);
+};
+
+NamedMapsController.prototype.setLastModifiedHeader = function () {
     return function setLastModifiedHeaderMiddleware(req, res, next) {
         const { affectedTablesAndLastUpdate } = res.locals;
 
@@ -464,9 +450,9 @@ function setLastModifiedHeader () {
 
         next();
     };
- }
+ };
 
-function setCacheControlHeader () {
+NamedMapsController.prototype.setCacheControlHeader = function () {
     return function setCacheControlHeaderMiddleware(req, res, next) {
         const { affectedTablesAndLastUpdate } = res.locals;
 
@@ -479,9 +465,9 @@ function setCacheControlHeader () {
 
         next();
     };
- }
+ };
 
-function setContentTypeHeader () {
+NamedMapsController.prototype.setContentTypeHeader = function () {
     return function setContentTypeHeaderMiddleware(req, res, next) {
         const { headers = {} } = res.locals;
 
@@ -489,10 +475,10 @@ function setContentTypeHeader () {
 
         next();
     };
-}
+};
 
-function sendResponse () {
-    return function sendResponseMiddleware (req, res) {
+NamedMapsController.prototype.respond = function () {
+    return function respondMiddleware (req, res) {
         const { body, stats = {}, format } = res.locals;
 
         req.profiler.done('render-' + format);
@@ -501,4 +487,4 @@ function sendResponse () {
         res.status(200);
         res.send(body);
     };
-}
+};

lib/cartodb/controllers/named_maps_admin.js

@@ -1,8 +1,6 @@
 const { templateName } = require('../backends/template_maps');
 const cors = require('../middleware/cors');
 const userMiddleware = require('../middleware/user');
-const localsMiddleware = require('../middleware/context/locals');
-const credentialsMiddleware = require('../middleware/context/credentials');
 
 /**
  * @param {AuthApi} authApi
@@ -23,58 +21,43 @@ NamedMapsAdminController.prototype.register = function (app) {
     app.post(
         `${base_url_templated}/`,
         cors(),
-        userMiddleware(),
-        localsMiddleware(),
-        credentialsMiddleware(),
-        checkContentType({ action: 'POST', label: 'POST TEMPLATE' }),
-        authorizedByAPIKey({ authApi: this.authApi, action: 'create', label: 'POST TEMPLATE' }),
-        createTemplate({ templateMaps: this.templateMaps }),
-        sendResponse()
+        userMiddleware,
+        this.checkContentType('POST', 'POST TEMPLATE'),
+        this.authorizedByAPIKey('create', 'POST TEMPLATE'),
+        this.create()
     );
 
     app.put(
         `${base_url_templated}/:template_id`,
         cors(),
-        userMiddleware(),
-        localsMiddleware(),
-        credentialsMiddleware(),
-        checkContentType({ action: 'PUT', label: 'PUT TEMPLATE' }),
-        authorizedByAPIKey({ authApi: this.authApi, action: 'update', label: 'PUT TEMPLATE' }),
-        updateTemplate({ templateMaps: this.templateMaps }),
-        sendResponse()
+        userMiddleware,
+        this.checkContentType('PUT', 'PUT TEMPLATE'),
+        this.authorizedByAPIKey('update', 'PUT TEMPLATE'),
+        this.update()
     );
 
     app.get(
         `${base_url_templated}/:template_id`,
         cors(),
-        userMiddleware(),
-        localsMiddleware(),
-        credentialsMiddleware(),
-        authorizedByAPIKey({ authApi: this.authApi, action: 'get', label: 'GET TEMPLATE' }),
-        retrieveTemplate({ templateMaps: this.templateMaps }),
-        sendResponse()
+        userMiddleware,
+        this.authorizedByAPIKey('get', 'GET TEMPLATE'),
+        this.retrieve()
     );
 
     app.delete(
         `${base_url_templated}/:template_id`,
         cors(),
-        userMiddleware(),
-        localsMiddleware(),
-        credentialsMiddleware(),
-        authorizedByAPIKey({ authApi: this.authApi, action: 'delete', label: 'DELETE TEMPLATE' }),
-        destroyTemplate({ templateMaps: this.templateMaps }),
-        sendResponse()
+        userMiddleware,
+        this.authorizedByAPIKey('delete', 'DELETE TEMPLATE'),
+        this.destroy()
     );
 
     app.get(
         `${base_url_templated}/`,
         cors(),
-        userMiddleware(),
-        localsMiddleware(),
-        credentialsMiddleware(),
-        authorizedByAPIKey({ authApi: this.authApi, action: 'list', label: 'GET TEMPLATE LIST' }),
-        listTemplates({ templateMaps: this.templateMaps }),
-        sendResponse()
+        userMiddleware,
+        this.authorizedByAPIKey('list', 'GET TEMPLATE LIST'),
+        this.list()
     );
 
     app.options(
@@ -83,23 +66,11 @@ NamedMapsAdminController.prototype.register = function (app) {
     );
 };
 
-function checkContentType ({ action, label }) {
-    return function checkContentTypeMiddleware (req, res, next) {
-        if (!req.is('application/json')) {
-            const error = new Error(`template ${action} data must be of type application/json`);
-            error.label = label;
-            return next(error);
-        }
-
-        next();
-    };
-}
-
-function authorizedByAPIKey ({ authApi, action, label }) {
+NamedMapsAdminController.prototype.authorizedByAPIKey = function (action, label) {
     return function authorizedByAPIKeyMiddleware (req, res, next) {
         const { user } = res.locals;
 
-        authApi.authorizedByAPIKey(user, res, (err, authenticated) => {
+        this.authApi.authorizedByAPIKey(user, req, (err, authenticated) => {
             if (err) {
                 return next(err);
             }
@@ -113,52 +84,65 @@ function authorizedByAPIKey ({ authApi, action, label }) {
 
             next();
         });
-    };
-}
+    }.bind(this);
+};
 
-function createTemplate ({ templateMaps }) {
+NamedMapsAdminController.prototype.checkContentType = function (action, label) {
+    return function checkContentTypeMiddleware (req, res, next) {
+        if (!req.is('application/json')) {
+            const error = new Error(`template ${action} data must be of type application/json`);
+            error.label = label;
+            return next(error);
+        }
+        next();
+    };
+};
+
+NamedMapsAdminController.prototype.create = function () {
     return function createTemplateMiddleware (req, res, next) {
         const { user } = res.locals;
         const template = req.body;
 
-        templateMaps.addTemplate(user, template, (err, templateId) => {
+        this.templateMaps.addTemplate(user, template, (err, templateId) => {
             if (err) {
                 return next(err);
             }
 
-            res.body = { template_id: templateId };
+            res.status(200);
 
-            next();
+            const method = req.query.callback ? 'jsonp' : 'json';
+            res[method]({ template_id: templateId });
         });
-    };
-}
+    }.bind(this);
+};
 
-function updateTemplate ({ templateMaps }) {
+NamedMapsAdminController.prototype.update = function () {
     return function updateTemplateMiddleware (req, res, next) {
         const { user } = res.locals;
         const template = req.body;
         const templateId = templateName(req.params.template_id);
 
-        templateMaps.updTemplate(user, templateId, template, (err) => {
+        this.templateMaps.updTemplate(user, templateId, template, (err) => {
             if (err) {
                 return next(err);
             }
 
-            res.body = { template_id: templateId };
+            res.status(200);
 
-            next();
+            const method = req.query.callback ? 'jsonp' : 'json';
+            res[method]({ template_id: templateId });
         });
-    };
-}
+    }.bind(this);
+};
 
-function retrieveTemplate ({ templateMaps }) {
+NamedMapsAdminController.prototype.retrieve =  function () {
     return function retrieveTemplateMiddleware (req, res, next) {
         req.profiler.start('windshaft-cartodb.get_template');
 
         const { user } = res.locals;
         const templateId = templateName(req.params.template_id);
 
-        templateMaps.getTemplate(user, templateId, (err, template) => {
+        this.templateMaps.getTemplate(user, templateId, (err, template) => {
             if (err) {
                 return next(err);
             }
@@ -172,56 +156,49 @@ function retrieveTemplate ({ templateMaps }) {
             // so we remove it before returning to the user
             delete template.auth_id;
 
-            res.body = { template };
+            res.status(200);
 
-            next();
+            const method = req.query.callback ? 'jsonp' : 'json';
+            res[method]({ template });
         });
-    };
-}
+    }.bind(this);
+};
 
-function destroyTemplate ({ templateMaps }) {
+NamedMapsAdminController.prototype.destroy = function () {
     return function destroyTemplateMiddleware (req, res, next) {
         req.profiler.start('windshaft-cartodb.delete_template');
 
         const { user } = res.locals;
         const templateId = templateName(req.params.template_id);
 
-        templateMaps.delTemplate(user, templateId, (err/* , tpl_val */) => {
+        this.templateMaps.delTemplate(user, templateId, (err/* , tpl_val */) => {
             if (err) {
                 return next(err);
             }
 
-            res.statusCode = 204;
-            res.body = '';
+            res.status(204);
 
-            next();
+            const method = req.query.callback ? 'jsonp' : 'json';
+            res[method]('');
         });
-    };
-}
+    }.bind(this);
+};
 
-function listTemplates ({ templateMaps }) {
+NamedMapsAdminController.prototype.list = function () {
     return function listTemplatesMiddleware (req, res, next) {
         req.profiler.start('windshaft-cartodb.get_template_list');
 
         const { user } = res.locals;
 
-        templateMaps.listTemplates(user, (err, templateIds) => {
+        this.templateMaps.listTemplates(user, (err, templateIds) => {
             if (err) {
                 return next(err);
             }
 
-            res.body = { template_ids: templateIds };
+            res.status(200);
 
-            next();
+            const method = req.query.callback ? 'jsonp' : 'json';
+            res[method]({ template_ids: templateIds });
         });
-    };
-}
-
-function sendResponse () {
-    return function sendResponseMiddleware (req, res) {
-        res.status(res.statusCode || 200);
-
-        const method = req.query.callback ? 'jsonp' : 'json';
-        res[method](res.body);
-    };
-}
+    }.bind(this);
+};

lib/cartodb/middleware/allow-query-params.js

@@ -1,9 +1,8 @@
-module.exports = function allowQueryParams (params) {
+module.exports = function allowQueryParams(params) {
     if (!Array.isArray(params)) {
         throw new Error('allowQueryParams must receive an Array of params');
     }
-
-    return function allowQueryParamsMiddleware (req, res, next) {
+    return function allowQueryParamsMiddleware(req, res, next) {
         res.locals.allowedQueryParams = params;
         next();
     };

lib/cartodb/middleware/context/authorize.js

@@ -1,8 +1,9 @@
-module.exports = function authorize (authApi) {
-    return function authorizeMiddleware (req, res, next) {
+module.exports = function authorizeMiddleware (authApi) {
+    return function (req, res, next) {
+        req.profiler.done('req2params.setup');
+
         authApi.authorize(req, res, (err, authorized) => {
             req.profiler.done('authorize');
-
             if (err) {
                 return next(err);
             }

lib/cartodb/middleware/context/credentials.js

@@ -1,85 +0,0 @@
-const basicAuth = require('basic-auth');
-
-module.exports = function credentials () {
-    return function credentialsMiddleware(req, res, next) {
-        const apikeyCredentials = getApikeyCredentialsFromRequest(req);
-
-        res.locals.api_key = apikeyCredentials.token;
-        res.locals.basicAuthUsername = apikeyCredentials.username;
-        res.set('vary', 'Authorization'); //Honor Authorization header when caching.
-
-        return next();
-    };
-};
-
-function getApikeyCredentialsFromRequest(req) {
-    let apikeyCredentials = {
-        token: null,
-        username: null,
-    };
-
-    for (let getter of apikeyGetters) {
-        apikeyCredentials = getter(req);
-        if (apikeyTokenFound(apikeyCredentials)) {
-            break;
-        }
-    }
-
-    return apikeyCredentials;
-}
-
-const apikeyGetters = [
-    getApikeyTokenFromHeaderAuthorization,
-    getApikeyTokenFromRequestQueryString,
-    getApikeyTokenFromRequestBody,
-];
-
-function getApikeyTokenFromHeaderAuthorization(req) {
-    const credentials = basicAuth(req);
-
-    if (credentials) {
-        return {
-            username: credentials.username,
-            token: credentials.pass
-        };
-    } else {
-        return {
-            username: null,
-            token: null,
-        };
-    }
-}
-
-function getApikeyTokenFromRequestQueryString(req) {
-    let token = null;
-
-    if (req.query && req.query.api_key) {
-        token = req.query.api_key;
-    } else if (req.query && req.query.map_key) {
-        token = req.query.map_key;
-    }
-
-    return {
-        username: null,
-        token: token,
-    };
-}
-
-function getApikeyTokenFromRequestBody(req) {
-    let token = null;
-
-    if (req.body && req.body.api_key) {
-        token = req.body.api_key;
-    } else if (req.body && req.body.map_key) {
-        token = req.body.map_key;
-    }
-
-    return {
-        username: null,
-        token: token,
-    };
-}
-
-function apikeyTokenFound(apikey) {
-    return !!apikey && !!apikey.token;
-}

lib/cartodb/middleware/context/db-conn-setup.js

@@ -1,30 +1,31 @@
 const _ = require('underscore');
 
-module.exports = function dbConnSetup (pgConnection) {
-    return function dbConnSetupMiddleware (req, res, next) {
-        const { user } = res.locals;
-
+module.exports = function dbConnSetupMiddleware(pgConnection) {
+    return function dbConnSetup(req, res, next) {
+        const user = res.locals.user;
         pgConnection.setDBConn(user, res.locals, (err) => {
-            req.profiler.done('dbConnSetup');
-
             if (err) {
                 if (err.message && -1 !== err.message.indexOf('name not found')) {
                     err.http_status = 404;
                 }
-
+                req.profiler.done('req2params');
                 return next(err);
             }
 
+            // Add default database connection parameters
+            // if none given
             _.defaults(res.locals, {
                 dbuser: global.environment.postgres.user,
                 dbpassword: global.environment.postgres.password,
                 dbhost: global.environment.postgres.host,
                 dbport: global.environment.postgres.port
             });
-
+            
             res.set('X-Served-By-DB-Host', res.locals.dbhost);
 
-            next();
+            req.profiler.done('req2params');
+            
+            next(null);
         });
     };
 };

lib/cartodb/middleware/context/index.js

@@ -1,16 +1,14 @@
 const locals = require('./locals');
 const cleanUpQueryParams = require('./clean-up-query-params');
 const layergroupToken = require('./layergroup-token');
-const credentials = require('./credentials');
 const authorize = require('./authorize');
 const dbConnSetup = require('./db-conn-setup');
 
 module.exports = function prepareContextMiddleware(authApi, pgConnection) {
     return [
-        locals(),
+        locals,
         cleanUpQueryParams(),
-        layergroupToken(),
-        credentials(),
+        layergroupToken,
         authorize(authApi),
         dbConnSetup(pgConnection)
     ];

lib/cartodb/middleware/context/layergroup-token.js

@@ -1,33 +1,32 @@
-const LayergroupToken = require('../../models/layergroup-token');
-const authErrorMessageTemplate = function (signer, user) {
-    return `Cannot use map signature of user "${signer}" on db of user "${user}"`;
-};
-
-module.exports = function layergroupToken () {
-    return function layergroupTokenMiddleware (req, res, next) {
-        if (!res.locals.token) {
-            return next();
-        }
-
-        const user = res.locals.user;
-
-        const layergroupToken = LayergroupToken.parse(res.locals.token);
-
-        res.locals.token = layergroupToken.token;
-        res.locals.cache_buster = layergroupToken.cacheBuster;
-
-        if (layergroupToken.signer) {
-            res.locals.signer = layergroupToken.signer;
-
-            if (res.locals.signer !== user) {
-                const err = new Error(authErrorMessageTemplate(res.locals.signer, user));
-                err.type = 'auth';
-                err.http_status = (req.query && req.query.callback) ? 200: 403;
-
-                return next(err);
-            }
-        }
+var LayergroupToken = require('../../models/layergroup-token');
 
+module.exports = function layergroupTokenMiddleware(req, res, next) {
+    if (!res.locals.token) {
         return next();
-    };
+    }
+
+    var user = res.locals.user;
+
+    var layergroupToken = LayergroupToken.parse(res.locals.token);
+    res.locals.token = layergroupToken.token;
+    res.locals.cache_buster = layergroupToken.cacheBuster;
+
+    if (layergroupToken.signer) {
+        res.locals.signer = layergroupToken.signer;
+        if (!res.locals.signer) {
+            res.locals.signer = user;
+        } else if (res.locals.signer !== user) {
+            var err = new Error(`Cannot use map signature of user "${res.locals.signer}" on db of user "${user}"`);
+            err.type = 'auth';
+            err.http_status = 403;
+            if (req.query && req.query.callback) {
+                err.http_status = 200;
+            }
+            
+            req.profiler.done('req2params');
+            return next(err);
+        }
+    }
+
+    return next();
 };

lib/cartodb/middleware/context/locals.js

@@ -1,7 +1,6 @@
-module.exports = function locals () {
-    return function localsMiddleware (req, res, next) {
-        res.locals = Object.assign(req.params || {}, res.locals);
+module.exports = function localsMiddleware(req, res, next) {
+    // save req.params in res.locals
+    res.locals = Object.assign(req.params || {}, res.locals);
 
-        next();
-    };
+    next();
 };

lib/cartodb/middleware/cors.js

@@ -1,14 +1,11 @@
-module.exports = function cors (extraHeaders) {
-    return function corsMiddleware (req, res, next) {
-        let baseHeaders = "X-Requested-With, X-Prototype-Version, X-CSRF-Token";
-
+module.exports = function cors(extraHeaders) {
+    return function(req, res, next) {
+        var baseHeaders = "X-Requested-With, X-Prototype-Version, X-CSRF-Token";
         if(extraHeaders) {
             baseHeaders += ", " + extraHeaders;
         }
-
         res.set("Access-Control-Allow-Origin", "*");
         res.set("Access-Control-Allow-Headers", baseHeaders);
-
         next();
     };
 };

lib/cartodb/middleware/lzma.js

@@ -1,33 +1,30 @@
+'use strict';
+
 const LZMA = require('lzma').LZMA;
 
-module.exports = function lzma () {
-    const lzmaWorker = new LZMA();
+const lzmaWorker = new LZMA();
 
-    return function lzmaMiddleware (req, res, next) {
-        if (!req.query.hasOwnProperty('lzma')) {
-            return next();
-        }
+module.exports = function lzmaMiddleware(req, res, next) {
+    if (!req.query.hasOwnProperty('lzma')) {
+        return next();
+    }
 
-        // Decode (from base64)
-        var lzma = new Buffer(req.query.lzma, 'base64')
-            .toString('binary')
-            .split('')
-            .map(function(c) {
-                return c.charCodeAt(0) - 128;
-            });
-
-        // Decompress
-        lzmaWorker.decompress(lzma, function(result) {
-            try {
-                delete req.query.lzma;
-                Object.assign(req.query, JSON.parse(result));
-
-                req.profiler.done('lzma');
-
-                next();
-            } catch (err) {
-                next(new Error('Error parsing lzma as JSON: ' + err));
-            }
+    // Decode (from base64)
+    var lzma = new Buffer(req.query.lzma, 'base64')
+        .toString('binary')
+        .split('')
+        .map(function(c) {
+            return c.charCodeAt(0) - 128;
         });
-    };
+
+    // Decompress
+    lzmaWorker.decompress(lzma, function(result) {
+        try {
+            delete req.query.lzma;
+            Object.assign(req.query, JSON.parse(result));
+            next();
+        } catch (err) {
+            next(new Error('Error parsing lzma as JSON: ' + err));
+        }
+    });
 };

lib/cartodb/middleware/stats.js

@@ -2,10 +2,10 @@ const Profiler = require('../stats/profiler_proxy');
 const debug = require('debug')('windshaft:cartodb:stats');
 const onHeaders = require('on-headers');
 
-module.exports = function stats (options) {
+module.exports = function statsMiddleware(options) {
     const { enabled = true, statsClient } = options;
 
-    return function statsMiddleware (req, res, next) {
+    return function stats(req, res, next) {
         req.profiler = new Profiler({
             statsd_client: statsClient,
             profile: enabled

lib/cartodb/middleware/user.js

@@ -1,11 +1,8 @@
-const CdbRequest = require('../models/cdb_request');
+var CdbRequest = require('../models/cdb_request');
+var cdbRequest = new CdbRequest();
 
-module.exports = function user () {
-    const cdbRequest = new CdbRequest();
+module.exports = function userMiddleware(req, res, next) {
+    res.locals.user = cdbRequest.userByReq(req);
 
-    return function userMiddleware(req, res, next) {
-        res.locals.user = cdbRequest.userByReq(req);
-
-        next();
-    };
+    next();
 };

lib/cartodb/middleware/vector-error.js

@@ -1,4 +1,5 @@
 const fs = require('fs');
+
 const timeoutErrorVectorTile = fs.readFileSync(__dirname + '/../../../assets/render-timeout-fallback.mvt');
 
 module.exports = function vectorError() {

lib/cartodb/models/aggregation/aggregation-query.js

@@ -131,12 +131,7 @@ const dimensionDefs = ctx => {
 // This is equivalent to `${256/ctx.res}*CDB_XYZ_Resolution(CDB_ZoomFromScale(!scale_denominator!))`
 // This is defined by the ctx.res parameter, which is the number of grid cells per tile linear dimension
 // (i.e. each tile is divided into ctx.res*ctx.res cells).
-// We limit the the minimum resolution to avoid division by zero problems. The limit used is
-// the pixel size of zoom level 30 (i.e. 1/2*(30+8) of the full earth web-mercator extent), which is about 0.15 mm.
-const gridResolution = ctx => {
-    const minimumResolution = 2*Math.PI*6378137/Math.pow(2,38);
-    return `GREATEST(${256*0.00028/ctx.res}*!scale_denominator!, ${minimumResolution})::double precision`;
-};
+const gridResolution = ctx => `(${256*0.00028/ctx.res}*!scale_denominator!)::double precision`;
 
 // Notes:
 // * We need to filter spatially using !bbox! to make the queries efficient because

lib/cartodb/models/dataview/aggregation.js

@@ -2,17 +2,19 @@ const BaseDataview = require('./base');
 const debug = require('debug')('windshaft:dataview:aggregation');
 
 const filteredQueryTpl = ctx => `
-    SELECT *
-    FROM (${ctx.query}) _cdb_filtered_source
-    ${ctx.aggregationColumn && ctx.isFloatColumn ? `
-    WHERE
-        ${ctx.aggregationColumn} != 'infinity'::float
-    AND
-        ${ctx.aggregationColumn} != '-infinity'::float
-    AND
-        ${ctx.aggregationColumn} != 'NaN'::float` :
-    ''
-    }
+    filtered_source AS (
+        SELECT *
+        FROM (${ctx.query}) _cdb_filtered_source
+        ${ctx.aggregationColumn && ctx.isFloatColumn ? `
+        WHERE
+            ${ctx.aggregationColumn} != 'infinity'::float
+        AND
+            ${ctx.aggregationColumn} != '-infinity'::float
+        AND
+            ${ctx.aggregationColumn} != 'NaN'::float` :
+        ''
+        }
+    )
 `;
 
 const summaryQueryTpl = ctx => `
@@ -41,8 +43,8 @@ const rankedCategoriesQueryTpl = ctx => `
             ${ctx.column} AS category,
             ${ctx.aggregationFn} AS value,
             row_number() OVER (ORDER BY ${ctx.aggregationFn} desc) as rank
-        FROM (${filteredQueryTpl(ctx)}) filtered_source
-        WHERE ${ctx.aggregation === "count" ? `${ctx.column}` : `${ctx.aggregationColumn}`} IS NOT NULL
+        FROM filtered_source
+        ${ctx.aggregationColumn !== null ? `WHERE ${ctx.aggregationColumn} IS NOT NULL` : ''}
         GROUP BY ${ctx.column}
         ORDER BY 2 DESC
     )
@@ -132,6 +134,7 @@ const aggregationFnQueryTpl = ctx => `${ctx.aggregation}(${ctx.aggregationColumn
 
 const aggregationDataviewQueryTpl = ctx => `
     WITH
+    ${filteredQueryTpl(ctx)},
     ${summaryQueryTpl(ctx)},
     ${rankedCategoriesQueryTpl(ctx)},
     ${categoriesSummaryMinMaxQueryTpl(ctx)},
@@ -279,7 +282,7 @@ module.exports = class Aggregation extends BaseDataview {
             max_val = 0,
             categories_count = 0
          } = result.rows[0] || {};
-
+        
         return {
             aggregation: this.aggregation,
             count: count,
@@ -290,10 +293,10 @@ module.exports = class Aggregation extends BaseDataview {
             max: max_val,
             categoriesCount: categories_count,
             categories: result.rows.map(({ category, value, agg }) => {
-                return {
+                return { 
                     category: agg ? 'Other' : category,
-                    value,
-                    agg
+                    value, 
+                    agg 
                 };
             })
         };

lib/cartodb/models/mapconfig/adapter/mapconfig-named-layers-adapter.js

@@ -108,7 +108,8 @@ MapConfigNamedLayersAdapter.prototype.getMapConfig = function (user, requestMapC
     var dbAuth = {};
 
     if (_.some(layers, isNamedTypeLayer)) {
-        this.pgConnection.setDBAuth(user, dbAuth, 'master', function(err) {
+        // Lazy load dbAuth
+        this.pgConnection.setDBAuth(user, dbAuth, function(err) {
             if (err) {
                 return callback(err);
             }

lib/cartodb/models/mapconfig/provider/named-map-provider.js

@@ -232,19 +232,19 @@ function configHash(config) {
 module.exports.configHash = configHash;
 
 NamedMapMapConfigProvider.prototype.setDBParams = function(cdbuser, params, callback) {
-    this.pgConnection.getDatabaseParams(cdbuser, (err, databaseParams) => {
-        if (err) {
-            return callback(err);
+    var self = this;
+    step(
+        function setAuth() {
+            self.pgConnection.setDBAuth(cdbuser, params, this);
+        },
+        function setConn(err) {
+            assert.ifError(err);
+            self.pgConnection.setDBConn(cdbuser, params, this);
+        },
+        function finish(err) {
+            callback(err);
         }
-
-        params.dbuser = databaseParams.dbuser;
-        params.dbpass = databaseParams.dbpass;
-        params.dbhost = databaseParams.dbhost;
-        params.dbport = databaseParams.dbport;
-        params.dbname = databaseParams.dbname;
-
-        callback();
-    });
+    );
 };
 
 NamedMapMapConfigProvider.prototype.getTemplateName = function() {

lib/cartodb/server.js

@@ -377,7 +377,7 @@ function bootstrap(opts) {
         statsClient: global.statsClient
     }));
 
-    app.use(lzmaMiddleware());
+    app.use(lzmaMiddleware);
 
     // temporary measure until we upgrade to newer version expressjs so we can check err.status
     app.use(function(err, req, res, next) {

lib/cartodb/server_options.js

@@ -15,7 +15,6 @@ var rendererConfig = _.defaults(global.environment.renderer || {}, {
         bufferSize: 64,
         snapToGrid: false,
         clipByBox2d: false,
-        metrics: false,
         limits: {}
     },
     http: {}

lib/cartodb/utils/layergroup-metadata.js

@@ -1,168 +0,0 @@
-module.exports = class LayergroupMetadata {
-    constructor (resourceLocator) {
-        this.resourceLocator = resourceLocator;
-    }
-
-    // TODO this should take into account several URL patterns
-    addDataviewsAndWidgetsUrls (username, layergroup, mapConfig) {
-        this._addDataviewsUrls(username, layergroup, mapConfig);
-        this._addWidgetsUrl(username, layergroup, mapConfig);
-    }
-
-    _addDataviewsUrls (username, layergroup, mapConfig) {
-        layergroup.metadata.dataviews = layergroup.metadata.dataviews || {};
-        var dataviews = mapConfig.dataviews || {};
-
-        Object.keys(dataviews).forEach((dataviewName) => {
-            var resource = layergroup.layergroupid + '/dataview/' + dataviewName;
-            layergroup.metadata.dataviews[dataviewName] = {
-                url: this.resourceLocator.getUrls(username, resource)
-            };
-        });
-    }
-
-    _addWidgetsUrl (username, layergroup, mapConfig) {
-        if (layergroup.metadata && Array.isArray(layergroup.metadata.layers) && Array.isArray(mapConfig.layers)) {
-            layergroup.metadata.layers = layergroup.metadata.layers.map((layer, layerIndex) => {
-                var mapConfigLayer = mapConfig.layers[layerIndex];
-                if (mapConfigLayer.options && mapConfigLayer.options.widgets) {
-                    layer.widgets = layer.widgets || {};
-                    Object.keys(mapConfigLayer.options.widgets).forEach((widgetName) => {
-                        var resource = layergroup.layergroupid + '/' + layerIndex + '/widget/' + widgetName;
-                        layer.widgets[widgetName] = {
-                            type: mapConfigLayer.options.widgets[widgetName].type,
-                            url: this.resourceLocator.getUrls(username, resource)
-                        };
-                    });
-                }
-
-                return layer;
-            });
-        }
-    }
-
-    addAnalysesMetadata (username, layergroup, analysesResults, includeQuery) {
-        includeQuery = includeQuery || false;
-        analysesResults = analysesResults || [];
-        layergroup.metadata.analyses = [];
-
-        analysesResults.forEach((analysis) => {
-            var nodes = analysis.getNodes();
-            layergroup.metadata.analyses.push({
-                nodes: nodes.reduce((nodesIdMap, node) => {
-                    if (node.params.id) {
-                        var nodeResource = layergroup.layergroupid + '/analysis/node/' + node.id();
-                        var nodeRepr = {
-                            status: node.getStatus(),
-                            url: this.resourceLocator.getUrls(username, nodeResource)
-                        };
-                        if (includeQuery) {
-                            nodeRepr.query = node.getQuery();
-                        }
-                        if (node.getStatus() === 'failed') {
-                            nodeRepr.error_message = node.getErrorMessage();
-                        }
-                        nodesIdMap[node.params.id] = nodeRepr;
-                    }
-
-                    return nodesIdMap;
-                }, {})
-            });
-        });
-    }
-
-    addAggregationContextMetadata (layergroup, mapConfig, context) {
-        if (layergroup.metadata && Array.isArray(layergroup.metadata.layers) && Array.isArray(mapConfig.layers)) {
-            layergroup.metadata.layers = layergroup.metadata.layers.map(function(layer, layerIndex) {
-                if (context.aggregation && Array.isArray(context.aggregation.layers)) {
-                    layer.meta.aggregation = context.aggregation.layers[layerIndex];
-                }
-                return layer;
-            });
-        }
-    }
-
-    addTileJsonMetadata (layergroup, user, mapconfig) {
-        const isVectorOnlyMapConfig = mapconfig.isVectorOnlyMapConfig();
-        let hasMapnikLayers = false;
-
-        layergroup.metadata.layers.forEach((layerMetadata, index) => {
-            const layerId = mapconfig.getLayerId(index);
-            const rasterResource = `${layergroup.layergroupid}/${layerId}/{z}/{x}/{y}.png`;
-            if (mapconfig.layerType(index) === 'mapnik') {
-                hasMapnikLayers = true;
-                const vectorResource = `${layergroup.layergroupid}/${layerId}/{z}/{x}/{y}.mvt`;
-                const layerTilejson = {
-                    vector: this._getTilejson(this.resourceLocator.getTileUrls(user, vectorResource))
-                };
-                if (!isVectorOnlyMapConfig) {
-                    let grids = null;
-                    const layer = mapconfig.getLayer(index);
-                    if (layer.options.interactivity) {
-                        const gridResource = `${layergroup.layergroupid}/${layerId}/{z}/{x}/{y}.grid.json`;
-                        grids = this.resourceLocator.getTileUrls(user, gridResource);
-                    }
-                    layerTilejson.raster = this._getTilejson(
-                        this.resourceLocator.getTileUrls(user, rasterResource),
-                        grids
-                    );
-                }
-                layerMetadata.tilejson = layerTilejson;
-            } else {
-                layerMetadata.tilejson = {
-                    raster: this._getTilejson(this.resourceLocator.getTileUrls(user, rasterResource))
-                };
-            }
-        });
-
-        const tilejson = {};
-        const url = {};
-
-        if (hasMapnikLayers) {
-            const vectorResource = `${layergroup.layergroupid}/{z}/{x}/{y}.mvt`;
-            tilejson.vector = this._getTilejson(
-                this.resourceLocator.getTileUrls(user, vectorResource)
-            );
-            url.vector = this._getTemplateUrl(this.resourceLocator.getTemplateUrls(user, vectorResource));
-
-            if (!isVectorOnlyMapConfig) {
-                const rasterResource = `${layergroup.layergroupid}/{z}/{x}/{y}.png`;
-                tilejson.raster = this._getTilejson(
-                    this.resourceLocator.getTileUrls(user, rasterResource)
-                );
-                url.raster = this._getTemplateUrl(this.resourceLocator.getTemplateUrls(user, rasterResource));
-            }
-        }
-
-        layergroup.metadata.tilejson = tilejson;
-        layergroup.metadata.url = url;
-    }
-
-    _getTilejson(tiles, grids) {
-        const tilejson = {
-            tilejson: '2.2.0',
-            tiles: tiles.https || tiles.http
-        };
-
-        if (grids) {
-            tilejson.grids = grids.https || grids.http;
-        }
-
-        return tilejson;
-    }
-
-    _getTemplateUrl(url) {
-        return url.https || url.http;
-    }
-
-    addTurboCartoContextMetadata(layergroup, mapConfig, context) {
-        if (layergroup.metadata && Array.isArray(layergroup.metadata.layers) && Array.isArray(mapConfig.layers)) {
-            layergroup.metadata.layers = layergroup.metadata.layers.map(function(layer, layerIndex) {
-                if (context.turboCarto && Array.isArray(context.turboCarto.layers)) {
-                    layer.meta.cartocss_meta = context.turboCarto.layers[layerIndex];
-                }
-                return layer;
-            });
-        }
-    }
-};

package.json

@@ -1,7 +1,7 @@
 {
   "private": true,
   "name": "windshaft-cartodb",
-  "version": "5.4.0",
+  "version": "5.0.2",
   "description": "A map tile server for CartoDB",
   "keywords": [
     "cartodb"
@@ -24,12 +24,11 @@
     "Simon Martin <simon@carto.com>"
   ],
   "dependencies": {
-    "basic-auth": "^2.0.0",
     "body-parser": "^1.18.2",
-    "camshaft": "0.61.4",
+    "camshaft": "0.62.1",
     "cartodb-psql": "0.10.2",
     "cartodb-query-tables": "0.3.0",
-    "cartodb-redis": "0.16.0",
+    "cartodb-redis": "0.14.0",
     "debug": "^3.1.0",
     "dot": "~1.0.2",
     "express": "~4.16.0",
@@ -41,14 +40,14 @@
     "node-statsd": "~0.0.7",
     "on-headers": "^1.0.1",
     "queue-async": "~1.0.7",
-    "redis-mpool": "0.5.0",
-    "request": "2.85.0",
+    "redis-mpool": "0.4.1",
+    "request": "^2.83.0",
     "semver": "~5.3.0",
     "step": "~0.0.6",
     "step-profiler": "~0.3.0",
     "turbo-carto": "0.20.2",
     "underscore": "~1.6.0",
-    "windshaft": "4.6.0",
+    "windshaft": "4.2.0",
     "yargs": "~5.0.0"
   },
   "devDependencies": {
@@ -57,7 +56,7 @@
     "mocha": "~3.4.1",
     "moment": "~2.18.1",
     "nock": "~2.11.0",
-    "redis": "2.8.0",
+    "redis": "~0.12.1",
     "strftime": "~0.8.2"
   },
   "scripts": {

test/acceptance/aggregation.js

@@ -1438,43 +1438,6 @@ describe('aggregation', function () {
                     done();
                 });
             });
-
-            it('aggregation should work with attributes', function (done) {
-                this.mapConfig = createVectorMapConfig([
-                    {
-                        type: 'cartodb',
-                        options: {
-                            sql: POINTS_SQL_1,
-                            cartocss: '#layer { marker-width: 7; }',
-                            cartocss_version: '2.3.0',
-                            aggregation: {
-                                threshold: 1
-                            },
-                            attributes: {
-                                id: 'cartodb_id',
-                                columns: [
-                                    'value'
-                                ]
-                            }
-                        }
-                    }
-                ]);
-                this.testClient = new TestClient(this.mapConfig);
-
-                this.testClient.getLayergroup((err, body) => {
-                    if (err) {
-                        return done(err);
-                    }
-
-                    assert.equal(typeof body.metadata, 'object');
-                    assert.ok(Array.isArray(body.metadata.layers));
-
-                    body.metadata.layers.forEach(layer => assert.ok(layer.meta.aggregation.mvt));
-                    body.metadata.layers.forEach(layer => assert.ok(layer.meta.aggregation.png));
-
-                    done();
-                });
-            });
         });
     });
 });

test/acceptance/analysis/error-cases.js

@@ -188,7 +188,7 @@ describe('analysis-layers error cases', function() {
             ]
         );
 
-        var testClient = new TestClient(mapConfig); //No apikey provided -> using default public apikey
+        var testClient = new TestClient(mapConfig, 11111);
 
         testClient.getLayergroup({ response: AUTH_ERROR_RESPONSE }, function(err, layergroupResult) {
             assert.ok(!err, err);

test/acceptance/auth/authorization-fallback.js

@@ -1,181 +0,0 @@
-//Remove this file when Auth fallback is not used anymore
-// AUTH_FALLBACK
-
-const assert = require('../../support/assert');
-const testHelper = require('../../support/test_helper');
-const CartodbWindshaft = require('../../../lib/cartodb/server');
-const serverOptions = require('../../../lib/cartodb/server_options');
-const server = new CartodbWindshaft(serverOptions);
-var LayergroupToken = require('../../../lib/cartodb/models/layergroup-token');
-
-function singleLayergroupConfig(sql, cartocss) {
-    return {
-        version: '1.7.0',
-        layers: [
-            {
-                type: 'mapnik',
-                options: {
-                    sql: sql,
-                    cartocss: cartocss,
-                    cartocss_version: '2.3.0'
-                }
-            }
-        ]
-    };
-}
-
-function createRequest(layergroup, userHost, apiKey) {
-    var url = layergroupUrl;
-    if (apiKey) {
-        url += '?api_key=' + apiKey;
-    }
-    return {
-        url: url,
-        method: 'POST',
-        headers: {
-            host: userHost || 'localhost',
-            'Content-Type': 'application/json'
-        },
-        data: JSON.stringify(layergroup)
-    };
-}
-
-var layergroupUrl = '/api/v1/map';
-var pointSqlMaster = "select * from test_table_private_1";
-var pointSqlPublic = "select * from test_table";
-var keysToDelete;
-
-describe('authorization fallback', function () {
-    beforeEach(function () {
-        keysToDelete = {};
-    });
-
-    afterEach(function (done) {
-        testHelper.deleteRedisKeys(keysToDelete, done);
-    });
-
-    it("succeed with master", function (done) {
-        var layergroup = singleLayergroupConfig(pointSqlMaster, '#layer { marker-fill:red; }');
-    
-        assert.response(server,
-            createRequest(layergroup, 'user_previous_to_project_auth', '4444'),
-            {
-                status: 200
-            },
-            function (res, err) {
-                assert.ifError(err);
-
-                var parsed = JSON.parse(res.body);
-                assert.ok(parsed.layergroupid);
-                assert.equal(res.headers['x-layergroup-id'], parsed.layergroupid);
-
-                keysToDelete['map_cfg|' + LayergroupToken.parse(parsed.layergroupid).token] = 0;
-                keysToDelete['user:user_previous_to_project_auth:mapviews:global'] = 5;
-
-                done();
-            }
-        );
-    });
-
-
-    it("succeed with default - sending default_public", function (done) {
-        var layergroup = singleLayergroupConfig(pointSqlPublic, '#layer { marker-fill:red; }');
-
-        assert.response(server,
-            createRequest(layergroup, 'user_previous_to_project_auth', 'default_public'),
-            {
-                status: 200
-            },
-            function (res, err) {
-                assert.ifError(err);
-
-                var parsed = JSON.parse(res.body);
-                assert.ok(parsed.layergroupid);
-                assert.equal(res.headers['x-layergroup-id'], parsed.layergroupid);
-
-                keysToDelete['map_cfg|' + LayergroupToken.parse(parsed.layergroupid).token] = 0;
-                keysToDelete['user:user_previous_to_project_auth:mapviews:global'] = 5;
-
-                done();
-            }
-        );
-    });
-
-    it("succeed with default - sending no api key token", function (done) {
-        var layergroup = singleLayergroupConfig(pointSqlPublic, '#layer { marker-fill:red; }');
-
-        assert.response(server,
-            createRequest(layergroup, 'user_previous_to_project_auth'),
-            {
-                status: 200
-            },
-            function (res, err) {
-                assert.ifError(err);
-
-                var parsed = JSON.parse(res.body);
-                assert.ok(parsed.layergroupid);
-                assert.equal(res.headers['x-layergroup-id'], parsed.layergroupid);
-
-                keysToDelete['map_cfg|' + LayergroupToken.parse(parsed.layergroupid).token] = 0;
-                keysToDelete['user:user_previous_to_project_auth:mapviews:global'] = 5;
-
-                done();
-            }
-        );
-    });
-
-    it("succeed with non-existent api key - defaults to default", function (done) {
-        var layergroup = singleLayergroupConfig(pointSqlPublic, '#layer { marker-fill:red; }');
-
-        assert.response(server,
-            createRequest(layergroup, 'user_previous_to_project_auth', 'THIS-API-KEY-DOESNT-EXIST'),
-            {
-                status: 200
-            },
-            function (res, err) {
-                assert.ifError(err);
-
-                var parsed = JSON.parse(res.body);
-                assert.ok(parsed.layergroupid);
-                assert.equal(res.headers['x-layergroup-id'], parsed.layergroupid);
-
-                keysToDelete['map_cfg|' + LayergroupToken.parse(parsed.layergroupid).token] = 0;
-                keysToDelete['user:user_previous_to_project_auth:mapviews:global'] = 5;
-
-                done();
-            }
-        );
-    });
-
-    it("fail with default", function (done) {
-        var layergroup = singleLayergroupConfig(pointSqlMaster, '#layer { marker-fill:red; }');
-
-        assert.response(server,
-            createRequest(layergroup, 'user_previous_to_project_auth', 'default_public'),
-            {
-                status: 403
-            },
-            function (res, err) {
-                assert.ifError(err);
-
-                done();
-            }
-        );
-    });
-
-    it("fail with non-existent api key - defaults to default", function (done) {
-        var layergroup = singleLayergroupConfig(pointSqlMaster, '#layer { marker-fill:red; }');
-
-        assert.response(server,
-            createRequest(layergroup, 'user_previous_to_project_auth', 'THIS-API-KEY-DOESNT-EXIST'),
-            {
-                status: 403
-            },
-            function (res, err) {
-                assert.ifError(err);
-
-                done();
-            }
-        );
-    });
-});

test/acceptance/auth/authorization.js

@@ -1,431 +0,0 @@
-require('../../support/test_helper');
-
-const assert = require('../../support/assert');
-const TestClient = require('../../support/test-client');
-const  mapnik = require('windshaft').mapnik;
-
-const PERMISSION_DENIED_RESPONSE = {
-    status: 403,
-    headers: {
-        'Content-Type': 'application/json; charset=utf-8'
-    }
-};
-
-describe('authorization', function() {
-    it('should create a layergroup with regular apikey token', function(done) {
-        const apikeyToken = 'regular1';
-        const mapConfig = {
-            version: '1.7.0',
-            layers: [
-                {
-                    options: {
-                        sql: 'select * FROM test_table_localhost_regular1',
-                        cartocss: TestClient.CARTOCSS.POINTS,
-                        cartocss_version: '2.3.0'
-                    }
-                }
-            ]
-        };
-        const testClient = new TestClient(mapConfig, apikeyToken);
-
-        testClient.getLayergroup(function (err, layergroupResult) {
-            assert.ifError(err);
-
-            assert.ok(layergroupResult.layergroupid);
-
-            testClient.drain(done);
-        });
-    });
-
-    it('should create and get a named map tile using a regular apikey token', function (done) {
-        const apikeyToken = 'regular1';
-        const mapConfig = {
-            version: '1.7.0',
-            layers: [
-                {
-                    options: {
-                        sql: 'select * FROM test_table_localhost_regular1',
-                        cartocss: TestClient.CARTOCSS.POINTS,
-                        cartocss_version: '2.3.0'
-                    }
-                }
-            ]
-        };
-        const testClient = new TestClient(mapConfig, apikeyToken);
-
-        testClient.getTile(0, 0, 0, function (err, res, tile) {
-            assert.ifError(err);
-
-            assert.equal(res.statusCode, 200);
-            assert.ok(tile instanceof mapnik.Image);
-
-            testClient.drain(done);
-        });
-    });    
-
-    it('should fail getting a named map tile with default apikey token', function (done) {
-        const apikeyTokenCreate = 'regular1';
-        const apikeyTokenGet = 'default_public';
-        const mapConfig = {
-            version: '1.7.0',
-            layers: [
-                {
-                    options: {
-                        sql: 'select * FROM test_table_localhost_regular1',
-                        cartocss: TestClient.CARTOCSS.POINTS,
-                        cartocss_version: '2.3.0'
-                    }
-                }
-            ]
-        };
-
-        const testClientCreate = new TestClient(mapConfig, apikeyTokenCreate);
-        testClientCreate.getLayergroup(function (err, layergroupResult) {
-            assert.ifError(err);
-            const layergroupId = layergroupResult.layergroupid;
-
-            const testClientGet = new TestClient({}, apikeyTokenGet);
-
-            const params = {
-                layergroupid: layergroupId,
-                response: PERMISSION_DENIED_RESPONSE
-            };
-
-            testClientGet.getTile(0, 0, 0, params, function(err, res, body) {
-
-                assert.ifError(err);
-
-                assert.ok(body.hasOwnProperty('errors'));
-                assert.equal(body.errors.length, 1);
-                assert.ok(body.errors[0].match(/permission denied/), body.errors[0]);
-
-                testClientGet.drain(done);
-            });
-        });
-    });
-
-    it('should fail creating a layergroup with default apikey token', function (done) {
-        const apikeyToken = 'default_public';
-        const mapConfig = {
-            version: '1.7.0',
-            layers: [
-                {
-                    options: {
-                        sql: 'select * FROM test_table_localhost_regular1',
-                        cartocss: TestClient.CARTOCSS.POINTS,
-                        cartocss_version: '2.3.0'
-                    }
-                }
-            ]
-        };
-        const testClient = new TestClient(mapConfig, apikeyToken);
-
-        testClient.getLayergroup({ response: { status: 403 } }, function (err, layergroupResult) {
-            assert.ifError(err);
-
-            assert.ok(layergroupResult.hasOwnProperty('errors'));
-            assert.equal(layergroupResult.errors.length, 1);
-            assert.ok(layergroupResult.errors[0].match(/permission denied/), layergroupResult.errors[0]);
-
-            testClient.drain(done);
-        });
-    });
-
-    it('should create a layergroup with default apikey token', function (done) {
-        const apikeyToken = 'default_public';
-        const mapConfig = {
-            version: '1.7.0',
-            layers: [
-                {
-                    options: {
-                        sql: 'select * FROM test_table',
-                        cartocss: TestClient.CARTOCSS.POINTS,
-                        cartocss_version: '2.3.0'
-                    }
-                }
-            ]
-        };
-        const testClient = new TestClient(mapConfig, apikeyToken);
-
-        testClient.getLayergroup(function (err, layergroupResult) {
-            assert.ifError(err);
-
-            assert.ok(layergroupResult.layergroupid);
-
-            testClient.drain(done);
-        });
-    });
-
-    it('should create and get a tile with default apikey token', function (done) {
-        const apikeyToken = 'default_public';
-        const mapConfig = {
-            version: '1.7.0',
-            layers: [
-                {
-                    options: {
-                        sql: 'select * FROM test_table',
-                        cartocss: TestClient.CARTOCSS.POINTS,
-                        cartocss_version: '2.3.0'
-                    }
-                }
-            ]
-        };
-        const testClient = new TestClient(mapConfig, apikeyToken);
-
-        testClient.getTile(0, 0, 0, function (err, res, tile) {
-            assert.ifError(err);
-
-            assert.equal(res.statusCode, 200);
-            assert.ok(tile instanceof mapnik.Image);
-
-            testClient.drain(done);
-        });
-    });
-
-    it('should fail if apikey does not grant access to table', function (done) {
-        const mapConfig = {
-            version: '1.7.0',
-            layers: [
-                {
-                    options: {
-                        sql: 'select * FROM test_table_localhost_regular1',
-                        cartocss: TestClient.CARTOCSS.POINTS,
-                        cartocss_version: '2.3.0'
-                    }
-                }
-            ]
-        };
-        const testClient = new TestClient(mapConfig); //no apikey provided, using default
-
-        testClient.getLayergroup({ response: { status: 403 } }, function (err, layergroupResult) { //TODO 401
-            assert.ifError(err);
-
-            assert.ok(layergroupResult.hasOwnProperty('errors'));
-            assert.equal(layergroupResult.errors.length, 1);
-            assert.ok(layergroupResult.errors[0].match(/permission denied/), layergroupResult.errors[0]);
-            
-            testClient.drain(done);
-        });
-    });
-
-    it('should forbide access to API if API key does not grant access', function (done) {
-        const apikeyToken = 'regular2';
-        const mapConfig = {
-            version: '1.7.0',
-            layers: [
-                {
-                    options: {
-                        sql: 'select * FROM test_table_localhost_regular1',
-                        cartocss: TestClient.CARTOCSS.POINTS,
-                        cartocss_version: '2.3.0'
-                    }
-                }
-            ]
-        };
-        const testClient = new TestClient(mapConfig, apikeyToken);
-
-        testClient.getLayergroup({ response: { status: 403 } }, function (err, layergroupResult) {
-            assert.ifError(err);
-
-            assert.ok(layergroupResult.hasOwnProperty('errors'));
-            assert.equal(layergroupResult.errors.length, 1);
-            assert.ok(layergroupResult.errors[0].match(/Forbidden/), layergroupResult.errors[0]);
-
-            testClient.drain(done);
-        });
-    });
-
-    it('should create a layergroup with a source analysis using a default apikey token', function (done) {
-        const apikeyToken = 'default_public';
-        const mapConfig = {
-            version: '1.7.0',
-            layers: [
-                {
-                    type: 'cartodb',
-                    options: {
-                        source: {
-                            id: 'HEAD'
-                        },
-                        cartocss: TestClient.CARTOCSS.POINTS,
-                        cartocss_version: '2.3.0'
-                    }
-                }
-            ],
-            analyses: [
-                {
-                    id: 'HEAD',
-                    type: 'source',
-                    params: {
-                        query: 'select * from populated_places_simple_reduced'
-                    }                        
-                }
-            ]
-        };
-        const testClient = new TestClient(mapConfig, apikeyToken);
-
-        testClient.getLayergroup(function (err, layergroupResult) {
-            assert.ifError(err);
-
-            assert.ok(layergroupResult.layergroupid);
-
-            testClient.drain(done);
-        });
-    });
-
-    it('should create a layergroup with a source analysis using a regular apikey token', function (done) {
-        const apikeyToken = 'regular1';
-        const mapConfig = {
-            version: '1.7.0',
-            layers: [
-                {
-                    type: 'cartodb',
-                    options: {
-                        source: {
-                            id: 'HEAD'
-                        },
-                        cartocss: TestClient.CARTOCSS.POINTS,
-                        cartocss_version: '2.3.0'
-                    }
-                }
-            ],
-            analyses: [
-                {
-                    id: 'HEAD',
-                    type: 'source',
-                    params: {
-                        query: 'select * from test_table_localhost_regular1'
-                    }
-                }
-            ]
-        };
-        const testClient = new TestClient(mapConfig, apikeyToken);
-
-        testClient.getLayergroup(function (err, layergroupResult) {
-            assert.ifError(err);
-
-            assert.ok(layergroupResult.layergroupid);
-
-            testClient.drain(done);
-        });
-    });
-
-    // Warning: TBA
-    it('should create a layergroup with a buffer analysis using a regular apikey token', function (done) {
-        const apikeyToken = 'regular1';
-        const mapConfig = {
-            version: '1.7.0',
-            layers: [
-                {
-                    type: 'cartodb',
-                    options: {
-                        source: {
-                            id: 'HEAD1'
-                        },
-                        cartocss: TestClient.CARTOCSS.POINTS,
-                        cartocss_version: '2.3.0'
-                    }
-                }
-            ],
-            analyses: [
-                {
-                    id: "HEAD1",
-                    type: "buffer",
-                    params: {
-                        source: {
-                            id: 'HEAD2',
-                            type: 'source',
-                            params: {
-                                query: 'select * from test_table_localhost_regular1'
-                            }
-                        },
-                        radius: 50000
-                    }
-                }
-            ]
-        };
-        const testClient = new TestClient(mapConfig, apikeyToken);
-
-        testClient.getLayergroup(function (err, layergroupResult) {
-            assert.ifError(err);
-
-            assert.ok(layergroupResult.layergroupid);
-
-            testClient.drain(done);
-        });
-    });
-
-    it('should create and get a named map tile using a regular apikey token', function (done) {
-        const apikeyToken = 'regular1';
-
-        const template = {
-            version: '0.0.1',
-            name: 'auth-api-template',
-            placeholders: {
-                buffersize: {
-                    type: 'number',
-                    default: 0
-                }
-            },
-            layergroup: {
-                version: '1.7.0',
-                layers: [{
-                    type: 'cartodb',
-                    options: {
-                        sql: 'select * from test_table_localhost_regular1',
-                        cartocss: TestClient.CARTOCSS.POINTS,
-                        cartocss_version: '2.3.0',
-                    }
-                }]
-            }
-        };
-
-        const testClient = new TestClient(template, apikeyToken);
-
-        testClient.getTile(0, 0, 0, function (err, res, tile) {
-            assert.ifError(err);
-
-            assert.equal(res.statusCode, 200);
-            assert.ok(tile instanceof mapnik.Image);
-
-            testClient.drain(done);
-        });
-    });
-
-    it('should fail creating a named map using a regular apikey token and a private table', function (done) {
-        const apikeyToken = 'regular1';
-
-        const template = {
-            version: '0.0.1',
-            name: 'auth-api-template-private',
-            placeholders: {
-                buffersize: {
-                    type: 'number',
-                    default: 0
-                }
-            },
-            layergroup: {
-                version: '1.7.0',
-                layers: [{
-                    type: 'cartodb',
-                    options: {
-                        sql: 'select * from populated_places_simple_reduced_private',
-                        cartocss: TestClient.CARTOCSS.POINTS,
-                        cartocss_version: '2.3.0',
-                    }
-                }]
-            }
-        };
-
-        const testClient = new TestClient(template, apikeyToken);
-
-        testClient.getTile(0, 0, 0, { response: PERMISSION_DENIED_RESPONSE }, function (err, res, body) {
-            assert.ifError(err);
-
-            assert.ok(body.hasOwnProperty('errors'));
-            assert.equal(body.errors.length, 1);
-            assert.ok(body.errors[0].match(/permission denied/), body.errors[0]);
-
-            testClient.drain(done);
-        });
-    });
-});

test/acceptance/cache/cache_headers.js

@@ -155,7 +155,6 @@ describe('get requests with cache headers', function() {
 
             assert.ok(res.headers['x-cache-channel']);
             assert.ok(res.headers['surrogate-key']);
-            assert.equal(res.headers.vary, 'Authorization');
             if (expectedCacheHeaders) {
                 validateXChannelHeaders(res.headers, expectedCacheHeaders);
                 assert.equal(res.headers['surrogate-key'], expectedCacheHeaders.surrogate_keys);

test/acceptance/dataviews/aggregation.js

@@ -70,8 +70,12 @@ describe('aggregations happy cases', function() {
     ].join(' UNION ALL ');
 
     operations.forEach(function (operation) {
-        var description = 'should handle NULL values in category and aggregation columns using "' +
-            operation + '" as aggregation operation';
+        var not = operation === 'count' ? ' not ' : ' ';
+        var description = 'should' +
+            not +
+            'handle NULL values in category and aggregation columns using "' +
+            operation +
+            '" as aggregation operation';
 
         it(description, function (done) {
             this.testClient = new TestClient(aggregationOperationMapConfig(operation, query, 'cat', 'val'));
@@ -92,7 +96,12 @@ describe('aggregations happy cases', function() {
                     }
                 });
 
-                assert.ok(!hasNullCategory, 'aggregation has category NULL');
+                if (operation === 'count') {
+                    assert.ok(hasNullCategory, 'aggregation has not a category NULL');
+                } else {
+                    assert.ok(!hasNullCategory, 'aggregation has category NULL');
+                }
+
                 done();
             });
         });
@@ -416,79 +425,3 @@ describe('aggregation dataview tuned by categories query param', function () {
         });
     });
 });
-
-
-
-describe('Count aggregation', function () {
-    const mapConfig = {
-        version: '1.5.0',
-        layers: [
-            {
-                type: "cartodb",
-                options: {
-                    source: {
-                        "id": "a0"
-                    },
-                    cartocss: "#points { marker-width: 10; marker-fill: red; }",
-                    cartocss_version: "2.3.0"
-                }
-            }
-        ],
-        dataviews: {
-            categories: {
-                source: {
-                    id: 'a0'
-                },
-                type: 'aggregation',
-                options: {
-                    column: 'cat',
-                    aggregation: 'count'
-                }
-            }
-        },
-        analyses: [
-            {
-                id: "a0",
-                type: "source",
-                params: {
-                    query: `
-                        SELECT
-                            null::geometry the_geom_webmercator,
-                            CASE
-                                WHEN x % 4 = 0 THEN 1
-                                WHEN x % 4 = 1 THEN 2
-                                WHEN x % 4 = 2 THEN 3
-                                ELSE null
-                            END AS val,
-                            CASE
-                                WHEN x % 4 = 0 THEN 'category_1'
-                                WHEN x % 4 = 1 THEN 'category_2'
-                                WHEN x % 4 = 2 THEN 'category_3'
-                                ELSE null
-                            END AS cat
-                        FROM generate_series(1, 1000) x
-                    `
-                }
-            }
-        ]
-    };
-
-    it(`should handle null values correctly when aggregationColumn isn't provided`, function (done) {
-        this.testClient = new TestClient(mapConfig, 1234);
-        this.testClient.getDataview('categories', { own_filter: 0, categories: 0 }, (err, dataview) => {
-            assert.ifError(err);
-            assert.equal(dataview.categories.length, 3);
-            this.testClient.drain(done);
-        });
-    });
-
-    it(`should handle null values correctly when aggregationColumn is provided`, function (done) {
-        mapConfig.dataviews.categories.options.aggregationColumn = 'val';
-        this.testClient = new TestClient(mapConfig, 1234);
-        this.testClient.getDataview('categories', { own_filter: 0, categories: 0 }, (err, dataview) => {
-            assert.ifError(err);
-            assert.equal(dataview.categories.length, 3);
-            this.testClient.drain(done);
-        });
-    });
-});

test/acceptance/mvt.js

@@ -34,48 +34,6 @@ return function () {
         serverOptions.renderer.mvt.usePostGIS = originalUsePostGIS;
     });
 
-    describe('named map tile', function () {
-        it('should get default named vector tile', function (done) {
-            const apikeyToken = 1234;
-            const templateName = `mvt-template-${usePostGIS ? 'postgis' : 'mapnik'}`;
-            const template = {
-                version: '0.0.1',
-                name: templateName,
-                placeholders: {
-                    buffersize: {
-                        type: 'number',
-                        default: 0
-                    }
-                },
-                layergroup: {
-                    version: '1.7.0',
-                    layers: [{
-                        type: 'cartodb',
-                        options: {
-                            sql: 'select * from populated_places_simple_reduced limit 10',
-                            cartocss: TestClient.CARTOCSS.POINTS,
-                            cartocss_version: '2.3.0',
-                        }
-                    }]
-                }
-            };
-
-            const testClient = new TestClient(template, apikeyToken);
-
-            testClient.getNamedTile(templateName, 0, 0, 0, 'mvt', {}, (err, res, tile) => {
-                if (err) {
-                    return done(err);
-                }
-
-                const tileJSON = tile.toJSON();
-
-                assert.equal(tileJSON[0].features.length, 10);
-
-                testClient.drain(done);
-            });
-        });
-    });
-
     describe('analysis-layers-dataviews-mvt', function () {
 
         function createMapConfig(layers, dataviews, analysis) {

test/acceptance/ported/attributes.js

@@ -125,7 +125,7 @@ describe('attributes', function() {
                     var parsed = JSON.parse(res.body);
                     assert.ok(parsed.errors);
                     var msg = parsed.errors[0];
-                    assert.equal(msg, "Multiple features (0) identified by 'i' = -666 in layer 1");
+                    assert.ok(msg.match(/0 features.*identified by fid -666/), msg);
                     return null;
                 },
                 function finish(err) {

test/acceptance/ported/support/ported_server_options.js

@@ -27,7 +27,6 @@ module.exports = _.extend({}, serverOptions, {
             snapToGrid: false,
             clipByBox2d: false, // this requires postgis >=2.2 and geos >=3.5
             scale_factors: [1, 2],
-            metrics: false,
             limits: {
                 render: 0,
                 cacheOnTimeout: true

test/support/prepare_db.sh

@@ -131,19 +131,6 @@ HMSET rails:users:cartodb250user id ${TESTUSERID} \
                                  map_key 4321
 EOF
 
-
-# Remove this block when Auth fallback is not used anymore
-# AUTH_FALLBACK
-  # A user to test auth fallback to no api keys mode
-  cat <<EOF | redis-cli -p ${REDIS_PORT} -n 5
-HMSET rails:users:user_previous_to_project_auth id ${TESTUSERID} \
-                                 database_name "${TEST_DB}" \
-                                 database_host "localhost" \
-                                 database_password "${TESTPASS}" \
-                                 database_publicuser "${PUBLICUSER}"\
-                                 map_key 4444
-EOF
-
   cat <<EOF | redis-cli -p ${REDIS_PORT} -n 0
 HSET rails:${TEST_DB}:my_table infowindow "this, that, the other"
 HSET rails:${TEST_DB}:test_table_private_1 privacy "0"
@@ -151,77 +138,4 @@ EOF
 
 fi
 
-# API keys ==============================
-
-# User localhost -----------------------
-
-# API Key Master
-cat <<EOF | redis-cli -p ${REDIS_PORT} -n 5
-  HMSET api_keys:localhost:1234 \
-    user "localhost" \
-    type "master" \
-    grants_sql "true" \
-    grants_maps "true" \
-    database_role "${TESTUSER}" \
-    database_password "${TESTPASS}"
-EOF
-
-# API Key Default public
-cat <<EOF | redis-cli -p ${REDIS_PORT} -n 5
-  HMSET api_keys:localhost:default_public \
-    user "localhost" \
-    type "default" \
-    grants_sql "true" \
-    grants_maps "true" \
-    database_role "test_windshaft_publicuser" \
-    database_password "public"
-EOF
-
-# API Key Regular
-cat <<EOF | redis-cli -p ${REDIS_PORT} -n 5
-  HMSET api_keys:localhost:regular1 \
-    user "localhost" \
-    type "regular" \
-    grants_sql "true" \
-    grants_maps "true" \
-    database_role "test_windshaft_regular1" \
-    database_password "regular1"
-EOF
-
-# API Key Regular 2 no Maps API access, only to check grants permissions to the API
-cat <<EOF | redis-cli -p ${REDIS_PORT} -n 5
-  HMSET api_keys:localhost:regular2 \
-    user "localhost" \
-    type "regular" \
-    grants_sql "true" \
-    grants_maps "false" \
-    database_role "test_windshaft_publicuser" \
-    database_password "public"
-EOF
-
-# User cartodb250user -----------------------
-
-# API Key Master
-cat <<EOF | redis-cli -p ${REDIS_PORT} -n 5
-  HMSET api_keys:cartodb250user:4321 \
-    user "localhost" \
-    type "master" \
-    grants_sql "true" \
-    grants_maps "true" \
-    database_role "${TESTUSER}" \
-    database_password "${TESTPASS}"
-EOF
-
-# API Key Default
-cat <<EOF | redis-cli -p ${REDIS_PORT} -n 5
-  HMSET api_keys:cartodb250user:default_public \
-    user "localhost" \
-    type "default" \
-    grants_sql "true" \
-    grants_maps "true" \
-    database_role "test_windshaft_publicuser" \
-    database_password "public"
-EOF
-
-
 echo "Finished preparing data. Ready to run tests"

test/support/sql/windshaft.test.sql

@@ -23,12 +23,6 @@ CREATE USER :PUBLICUSER WITH PASSWORD ':PUBLICPASS';
 DROP USER IF EXISTS :TESTUSER;
 CREATE USER :TESTUSER WITH PASSWORD ':TESTPASS';
 
--- regular user role 1
-DROP USER IF EXISTS test_windshaft_regular1;
-CREATE USER test_windshaft_regular1 WITH PASSWORD 'regular1';
-
-GRANT test_windshaft_regular1 to :TESTUSER;
-
 -- first table
 CREATE TABLE test_table (
     updated_at timestamp without time zone DEFAULT now(),
@@ -195,7 +189,6 @@ INSERT INTO CDB_TableMetadata (tabname, updated_at) VALUES ('test_table_private_
 
 -- GRANT SELECT ON CDB_TableMetadata TO :PUBLICUSER;
 GRANT SELECT ON CDB_TableMetadata TO :TESTUSER;
-GRANT SELECT ON CDB_TableMetadata TO test_windshaft_regular1; -- for analysis. Warning: TBA
 
 -- long name table
 CREATE TABLE
@@ -419,52 +412,6 @@ INSERT INTO _vovw_1_test_special_float_values_table_overviews VALUES
 (3, 'El Rey del Tallarín', 'Plaza Conde de Toreno 2, Madrid, Spain', 'NaN'::float, '0101000020E610000021C8410933AD0DC0CB0EF10F5B364440', '0101000020110F000053E71AC64D3419C10F664E4659CC5241', 1),
 (4, 'El Lacón', 'Manuel Fernández y González 8, Madrid, Spain', 'infinity'::float, '0101000020E6100000BC5983F755990DC07D923B6C22354440', '0101000020110F00005DACDB056F2319C1EC41A980FCCA5241', 2);
 
--- auth tables --------------------------------------------
-
-CREATE TABLE test_table_localhost_regular1 (
-    updated_at timestamp without time zone DEFAULT now(),
-    created_at timestamp without time zone DEFAULT now(),
-    cartodb_id integer NOT NULL,
-    name character varying,
-    address character varying,
-    the_geom geometry,
-    the_geom_webmercator geometry,
-    CONSTRAINT enforce_dims_the_geom CHECK ((st_ndims(the_geom) = 2)),
-    CONSTRAINT enforce_dims_the_geom_webmercator CHECK ((st_ndims(the_geom_webmercator) = 2)),
-    CONSTRAINT enforce_geotype_the_geom CHECK (((geometrytype(the_geom) = 'POINT'::text) OR (the_geom IS NULL))),
-    CONSTRAINT enforce_geotype_the_geom_webmercator CHECK (((geometrytype(the_geom_webmercator) = 'POINT'::text) OR (the_geom_webmercator IS NULL))),
-    CONSTRAINT enforce_srid_the_geom CHECK ((st_srid(the_geom) = 4326)),
-    CONSTRAINT enforce_srid_the_geom_webmercator CHECK ((st_srid(the_geom_webmercator) = 3857))
-);
-
-CREATE SEQUENCE test_table_localhost_regular1_cartodb_id_seq
-    START WITH 1
-    INCREMENT BY 1
-    NO MINVALUE
-    NO MAXVALUE
-    CACHE 1;
-
-ALTER SEQUENCE test_table_localhost_regular1_cartodb_id_seq OWNED BY test_table_localhost_regular1.cartodb_id;
-
-SELECT pg_catalog.setval('test_table_localhost_regular1_cartodb_id_seq', 60, true);
-
-ALTER TABLE test_table_localhost_regular1 ALTER COLUMN cartodb_id SET DEFAULT nextval('test_table_localhost_regular1_cartodb_id_seq'::regclass);
-
-INSERT INTO test_table_localhost_regular1 VALUES
-('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.314252', 1, 'Hawai', 'Calle de Pérez Galdós 9, Madrid, Spain', '0101000020E6100000A6B73F170D990DC064E8D84125364440', '0101000020110F000076491621312319C122D4663F1DCC5241'),
-('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.319101', 2, 'El Estocolmo', 'Calle de la Palma 72, Madrid, Spain', '0101000020E6100000C90567F0F7AB0DC0AB07CC43A6364440', '0101000020110F0000C4356B29423319C15DD1092DADCC5241'),
-('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.324', 3, 'El Rey del Tallarín', 'Plaza Conde de Toreno 2, Madrid, Spain', '0101000020E610000021C8410933AD0DC0CB0EF10F5B364440', '0101000020110F000053E71AC64D3419C10F664E4659CC5241'),
-('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.329509', 4, 'El Lacón', 'Manuel Fernández y González 8, Madrid, Spain', '0101000020E6100000BC5983F755990DC07D923B6C22354440', '0101000020110F00005DACDB056F2319C1EC41A980FCCA5241'),
-('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.334931', 5, 'El Pico', 'Calle Divino Pastor 12, Madrid, Spain', '0101000020E61000003B6D8D08C6A10DC0371B2B31CF364440', '0101000020110F00005F716E91992A19C17DAAA4D6DACC5241');
-
-ALTER TABLE ONLY test_table_localhost_regular1 ADD CONSTRAINT test_table_localhost_regular1_pkey PRIMARY KEY (cartodb_id);
-
-CREATE INDEX test_table_localhost_regular1_the_geom_idx ON test_table_localhost_regular1 USING gist (the_geom);
-CREATE INDEX test_table_localhost_regular1_the_geom_webmercator_idx ON test_table_localhost_regular1 USING gist (the_geom_webmercator);
-
-GRANT ALL ON TABLE test_table_localhost_regular1 TO :TESTUSER;
-GRANT ALL ON TABLE test_table_localhost_regular1 TO test_windshaft_regular1;
-
 -- analysis tables -----------------------------------------------
 
 ALTER TABLE cdb_analysis_catalog OWNER TO :TESTUSER;
@@ -758,7 +705,6 @@ GRANT SELECT ON TABLE analysis_rent_listings TO :PUBLICUSER;
 
 --
 GRANT SELECT, UPDATE, INSERT, DELETE ON cdb_analysis_catalog TO :TESTUSER;
-GRANT SELECT, UPDATE, INSERT, DELETE ON cdb_analysis_catalog TO test_windshaft_regular1; -- for analysis. Warning: TBA
 
 DROP EXTENSION IF EXISTS crankshaft;
 CREATE SCHEMA IF NOT EXISTS cdb_crankshaft;

test/support/test-client.js

@@ -414,7 +414,7 @@ TestClient.prototype.getDataview = function(dataviewName, params, callback) {
             var urlParams = {};
             if (params.hasOwnProperty('no_filters')) {
                 urlParams.no_filters = params.no_filters;
-            }
+            } 
             if (params.hasOwnProperty('own_filter')) {
                 urlParams.own_filter = params.own_filter;
             }
@@ -1253,87 +1253,3 @@ TestClient.prototype.getAnalysesCatalog = function (params, callback) {
         }
     );
 };
-
-TestClient.prototype.getNamedTile =  function (name, z, x, y, format, options, callback) {
-    const { params }  = options;
-
-    if (!this.apiKey) {
-        return callback(new Error('apiKey param is mandatory to create a new template'));
-    }
-
-    const createTemplateRequest = {
-        url: `/api/v1/map/named?${qs.stringify({ api_key: this.apiKey })}`,
-        method: 'POST',
-        headers: {
-            host: 'localhost',
-            'Content-Type': 'application/json'
-        },
-        data: JSON.stringify(this.template)
-    };
-
-    const createTemplateResponse = {
-        status: 200,
-        headers: {
-            'Content-Type': 'application/json; charset=utf-8'
-        }
-    };
-
-    assert.response(this.server, createTemplateRequest, createTemplateResponse, (res, err) => {
-        if (err) {
-            return callback(err);
-        }
-
-        const templateId = JSON.parse(res.body).template_id;
-        const queryParams = params ? `?${qs.stringify(params)}` : '';
-        const url = `/api/v1/map/named/${templateId}/all/${[z,x,y].join('/')}.${format}${queryParams}`;
-        const namedTileRequest = {
-            url,
-            method: 'GET',
-            headers: {
-                host: 'localhost'
-            },
-            encoding: 'binary'
-        };
-
-        let contentType;
-        switch (format) {
-            case 'png':
-                contentType = 'image/png';
-                break;
-            case 'mvt':
-                contentType = 'application/x-protobuf';
-                break;
-            default:
-                contentType = 'application/json';
-                break;
-        }
-
-        const namedTileResponse = Object.assign({
-            status: 200,
-            headers: {
-                'content-type': contentType
-            }
-        }, options.response);
-
-        assert.response(this.server, namedTileRequest, namedTileResponse, (res, err) => {
-            let body;
-            switch (res.headers['content-type']) {
-                case 'image/png':
-                    body = mapnik.Image.fromBytes(new Buffer(res.body, 'binary'));
-                    break;
-                case 'application/x-protobuf':
-                    body = new mapnik.VectorTile(z, x, y);
-                    body.setDataSync(new Buffer(res.body, 'binary'));
-                    break;
-                case 'application/json; charset=utf-8':
-                    body = JSON.parse(res.body);
-                    break;
-                default:
-                    body = res.body;
-                    break;
-            }
-
-            return callback(err, res, body);
-        });
-    });
-};

test/support/test_helper.js

@@ -113,14 +113,7 @@ afterEach(function(done) {
         'rails:test_windshaft_cartodb_user_1_db:my_table': true,
         'rails:users:localhost:map_key': true,
         'rails:users:cartodb250user': true,
-        'rails:users:localhost': true,
-        'rails:users:user_previous_to_project_auth': true, // AUTH_FALLBACK
-        'api_keys:localhost:1234': true,
-        'api_keys:localhost:default_public': true,
-        'api_keys:cartodb250user:4321': true,
-        'api_keys:cartodb250user:default_public': true,
-        'api_keys:localhost:regular1': true,
-        'api_keys:localhost:regular2': true,
+        'rails:users:localhost': true
     };
     var databasesTasks = { 0: 'users', 5: 'meta'};
 

test/unit/cartodb/lzmaMiddleware.test.js

@@ -12,7 +12,6 @@ describe('lzma-middleware', function() {
             }
         };
         testHelper.lzma_compress_to_base64(JSON.stringify(qo), 1, function(err, data) {
-            const lzma = lzmaMiddleware();
             var req = {
                 headers: {
                     host:'localhost'
@@ -20,13 +19,9 @@ describe('lzma-middleware', function() {
                 query: {
                     api_key: 'test',
                     lzma: data
-                },
-                profiler: {
-                    done: function () {}
                 }
             };
-
-            lzma(req, {}, function(err) {
+            lzmaMiddleware(req, {}, function(err) {
                 if ( err ) {
                     return done(err);
                 }

test/unit/cartodb/ported/tile_stats.test.js

@@ -0,0 +1,90 @@
+require('../../../support/test_helper.js');
+
+var assert = require('assert');
+
+var LayergroupController = require('../../../../lib/cartodb/controllers/layergroup');
+
+describe('tile stats', function() {
+
+    beforeEach(function () {
+        this.statsClient = global.statsClient;
+    });
+
+    afterEach(function() {
+        global.statsClient = this.statsClient;
+    });
+
+    it('finalizeGetTileOrGrid does not call statsClient when format is not supported', function() {
+        var expectedCalls = 2, // it will call increment once for the general error
+            invalidFormat = 'png2',
+            invalidFormatRegexp = new RegExp('invalid'),
+            formatMatched = false;
+        mockStatsClientGetInstance({
+            increment: function(label) {
+                formatMatched = formatMatched || !!label.match(invalidFormatRegexp);
+                expectedCalls--;
+            }
+        });
+
+        var layergroupController = new LayergroupController();
+
+        var reqMock = {
+            profiler: { toJSONString:function() {} },
+            params: {
+                format: invalidFormat
+            }
+        };
+        var resMock = {
+            status: function() { return this; },
+            set: function() {},
+            json: function() {},
+            jsonp: function() {},
+            send: function() {}
+        };
+
+        var next = function () {};
+        layergroupController.finalizeGetTileOrGrid('Unsupported format png2', reqMock, resMock, null, null, next);
+
+        assert.ok(formatMatched, 'Format was never matched in increment method');
+        assert.equal(expectedCalls, 0, 'Unexpected number of calls to increment method');
+    });
+
+    it('finalizeGetTileOrGrid calls statsClient when format is supported', function() {
+        var expectedCalls = 2, // general error + format error
+            validFormat = 'png',
+            validFormatRegexp = new RegExp(validFormat),
+            formatMatched = false;
+        mockStatsClientGetInstance({
+            increment: function(label) {
+                formatMatched = formatMatched || !!label.match(validFormatRegexp);
+                expectedCalls--;
+            }
+        });
+        var reqMock = {
+            profiler: { toJSONString:function() {} },
+            params: {
+                format: validFormat
+            }
+        };
+        var resMock = {
+            status: function() { return this; },
+            set: function() {},
+            json: function() {},
+            jsonp: function() {},
+            send: function() {}
+        };
+
+        var layergroupController = new LayergroupController();
+
+        var next = function () {};
+        layergroupController.finalizeGetTileOrGrid('Another error happened', reqMock, resMock, null, null, next);
+
+        assert.ok(formatMatched, 'Format was never matched in increment method');
+        assert.equal(expectedCalls, 0, 'Unexpected number of calls to increment method');
+    });
+
+    function mockStatsClientGetInstance(instance) {
+        global.statsClient = Object.assign(global.statsClient, instance);
+    }
+
+});

test/unit/cartodb/prepare-context.test.js

@@ -10,7 +10,6 @@ var TemplateMaps = require('../../../lib/cartodb/backends/template_maps');
 const cleanUpQueryParamsMiddleware = require('../../../lib/cartodb/middleware/context/clean-up-query-params');
 const authorizeMiddleware = require('../../../lib/cartodb/middleware/context/authorize');
 const dbConnSetupMiddleware = require('../../../lib/cartodb/middleware/context/db-conn-setup');
-const credentialsMiddleware = require('../../../lib/cartodb/middleware/context/credentials');
 const localsMiddleware =  require('../../../lib/cartodb/middleware/context/locals');
 
 var windshaft = require('windshaft');
@@ -24,7 +23,6 @@ describe('prepare-context', function() {
     let cleanUpQueryParams;
     let dbConnSetup;
     let authorize;
-    let setCredentials;
 
     before(function() {
         var redisPool = new RedisPool(global.environment.redis);
@@ -37,7 +35,6 @@ describe('prepare-context', function() {
         cleanUpQueryParams = cleanUpQueryParamsMiddleware();
         authorize = authorizeMiddleware(authApi);
         dbConnSetup = dbConnSetupMiddleware(pgConnection);
-        setCredentials = credentialsMiddleware();
     });
 
 
@@ -61,23 +58,20 @@ describe('prepare-context', function() {
         }
         res.locals.user = 'localhost';
 
-        res.set = function () {};
-
         return res;
     }
 
     it('res.locals are created', function(done) {
-        const locals = localsMiddleware();
         let req = {};
         let res = {};
 
-        locals(prepareRequest(req), prepareResponse(res), function(err) {
+        localsMiddleware(prepareRequest(req), prepareResponse(res), function(err) {
             if ( err ) { done(err); return; }
             assert.ok(res.hasOwnProperty('locals'), 'response has locals');
             done();
         });
     });
-
+    
     it('cleans up request', function(done){
       var req = {headers: { host:'localhost' }, query: {dbuser:'hacker',dbname:'secret'}};
       var res = {};
@@ -109,20 +103,8 @@ describe('prepare-context', function() {
     });
 
     it('sets also dbuser for authenticated requests', function(done){
-        var req = {
-            headers: {
-                host: 'localhost'
-            },
-            query: {
-                api_key: '1234'
-            }
-        };
-        var res = {
-            set: function () {},
-            locals: {
-                api_key: '1234'
-            }
-        };
+        var req = { headers: { host: 'localhost' }, query: { map_key: '1234' }};
+        var res = { set: function () {} };
 
         // FIXME: review authorize-pgconnsetup workflow, It might we are doing authorization twice.
         authorize(prepareRequest(req), prepareResponse(res), function (err) {
@@ -172,7 +154,7 @@ describe('prepare-context', function() {
             }
         };
         var res = {};
-
+        
         cleanUpQueryParams(prepareRequest(req), prepareResponse(res), function (err) {
             if ( err ) {
                 return done(err);
@@ -186,66 +168,4 @@ describe('prepare-context', function() {
         });
     });
 
-    describe('Set apikey token', function(){
-        it('from query param', function (done) {
-            var req = {
-                headers: {
-                    host: 'localhost'
-                },
-                query: {
-                    api_key: '1234',
-                }
-            };
-            var res = {};
-            setCredentials(prepareRequest(req), prepareResponse(res), function (err) {
-                if (err) {
-                    return done(err);
-                }
-                var query = res.locals;
-
-                assert.equal('1234', query.api_key);
-                done();
-            });
-        });
-
-        it('from body param', function (done) {
-            var req = {
-                headers: {
-                    host: 'localhost'
-                },
-                body: {
-                    api_key: '1234',
-                }
-            };
-            var res = {};
-            setCredentials(prepareRequest(req), prepareResponse(res), function (err) {
-                if (err) {
-                    return done(err);
-                }
-                var query = res.locals;
-
-                assert.equal('1234', query.api_key);
-                done();
-            });
-        });
-
-        it('from http header', function (done) {
-            var req = {
-                headers: {
-                    host: 'localhost',
-                    authorization: 'Basic bG9jYWxob3N0OjEyMzQ=', // user: localhost, password: 1234
-                }
-            };
-            var res = {};
-            setCredentials(prepareRequest(req), prepareResponse(res), function (err) {
-                if (err) {
-                    return done(err);
-                }
-                var query = res.locals;
-
-                assert.equal('1234', query.api_key);
-                done();
-            });
-        });
-    });
 });

yarn.lock

@@ -2,36 +2,19 @@
 # yarn lockfile v1
 
 
-"@carto/mapnik@3.6.2-carto.4":
-  version "3.6.2-carto.4"
-  resolved "https://registry.yarnpkg.com/@carto/mapnik/-/mapnik-3.6.2-carto.4.tgz#54042a5dbea293c54e1bd286b32277694c5dc2d2"
+abaculus@cartodb/abaculus#2.0.3-cdb1:
+  version "2.0.3-cdb1"
+  resolved "https://codeload.github.com/cartodb/abaculus/tar.gz/f5f34e1c80cdd8d49edd1d6fe3b2220ab2e23aaf"
   dependencies:
-    mapnik-vector-tile "1.5.0"
-    nan "~2.7.0"
-    node-pre-gyp "~0.6.30"
-    protozero "1.5.1"
-
-"@carto/tilelive-bridge@cartodb/tilelive-bridge#2.5.1-cdb4":
-  version "2.5.1-cdb4"
-  resolved "https://codeload.github.com/cartodb/tilelive-bridge/tar.gz/3eb554e5109199f50f457cec72ee288cffa5d6b3"
-  dependencies:
-    "@carto/mapnik" "3.6.2-carto.4"
-    "@mapbox/sphericalmercator" "~1.0.1"
-    mapnik-pool "~0.1.3"
-
-"@mapbox/sphericalmercator@~1.0.1":
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/@mapbox/sphericalmercator/-/sphericalmercator-1.0.5.tgz#70237b9774095ed1cfdbcea7a8fd1fc82b2691f2"
-
-abaculus@cartodb/abaculus#2.0.3-cdb5:
-  version "2.0.3-cdb5"
-  resolved "https://codeload.github.com/cartodb/abaculus/tar.gz/b899cbea04b3e6093aa3ef32331920acd5f839a1"
-  dependencies:
-    "@carto/mapnik" "3.6.2-carto.4"
     d3-queue "^2.0.2"
+    mapnik "~3.5.0"
     sphericalmercator "1.0.x"
 
-abbrev@1, abbrev@1.0.x:
+abbrev@1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/abbrev/-/abbrev-1.1.1.tgz#f8f2c887ad10bf67f634f005b6987fed3179aac8"
+
+abbrev@1.0.x:
   version "1.0.9"
   resolved "https://registry.yarnpkg.com/abbrev/-/abbrev-1.0.9.tgz#91b4792588a7738c25f35dd6f63752a2f8776135"
 
@@ -112,8 +95,8 @@ assert-plus@^0.2.0:
   resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-0.2.0.tgz#d74e1b87e7affc0db8aadb7021f3fe48101ab234"
 
 assertion-error@^1.0.1:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/assertion-error/-/assertion-error-1.1.0.tgz#e60b6b0e8f301bd97e5375215bda406c85118c0b"
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/assertion-error/-/assertion-error-1.0.2.tgz#13ca515d86206da0bac66e834dd397d87581094c"
 
 async@1.x, async@^1.4.0, async@^1.5.2:
   version "1.5.2"
@@ -143,12 +126,6 @@ balanced-match@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.0.tgz#89b4d199ab2bee49de164ea02b89ce462d71b767"
 
-basic-auth@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/basic-auth/-/basic-auth-2.0.0.tgz#015db3f353e02e56377755f962742e8981e7bbba"
-  dependencies:
-    safe-buffer "5.1.1"
-
 bcrypt-pbkdf@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.1.tgz#63bc5dcb61331b92bc05fd528953c33462a06f8d"
@@ -238,13 +215,13 @@ camelcase@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-3.0.0.tgz#32fc4b9fcdaf845fcdf7e73bb97cac2261f0ab0a"
 
-camshaft@0.61.4:
-  version "0.61.4"
-  resolved "https://registry.yarnpkg.com/camshaft/-/camshaft-0.61.4.tgz#eeab7e69a07d6fbc39ebc01ad19acf979de8fb2a"
+camshaft@0.62.1:
+  version "0.62.1"
+  resolved "https://registry.yarnpkg.com/camshaft/-/camshaft-0.62.1.tgz#75f8734c4089aaeae3b9067eb94d3c669cebbcaf"
   dependencies:
     async "^1.5.2"
     bunyan "1.8.1"
-    cartodb-psql "^0.10.1"
+    cartodb-psql "0.11.0"
     debug "^3.1.0"
     dot "^1.0.3"
     request "2.85.0"
@@ -297,16 +274,24 @@ cartodb-psql@0.10.2, cartodb-psql@^0.10.1:
     pg cartodb/node-postgres#6.1.6-cdb1
     underscore "~1.6.0"
 
+cartodb-psql@0.11.0:
+  version "0.11.0"
+  resolved "https://registry.yarnpkg.com/cartodb-psql/-/cartodb-psql-0.11.0.tgz#6b4eae0876ee56944a61fe5f4acc6a8b0b11233f"
+  dependencies:
+    debug "^3.1.0"
+    pg CartoDB/node-postgres#6.4.2-cdb1
+    underscore "~1.6.0"
+
 cartodb-query-tables@0.3.0:
   version "0.3.0"
   resolved "https://registry.yarnpkg.com/cartodb-query-tables/-/cartodb-query-tables-0.3.0.tgz#56e18d869666eb2e8e2cb57d0baf3acc923f8756"
 
-cartodb-redis@0.16.0:
-  version "0.16.0"
-  resolved "https://registry.yarnpkg.com/cartodb-redis/-/cartodb-redis-0.16.0.tgz#969312fd329b24a76bf6e5a4dd961445f2eda734"
+cartodb-redis@0.14.0:
+  version "0.14.0"
+  resolved "https://registry.yarnpkg.com/cartodb-redis/-/cartodb-redis-0.14.0.tgz#6f82fdb3e5b7c8005dbaccd6172c1706c4378df2"
   dependencies:
     dot "~1.0.2"
-    redis-mpool "^0.5.0"
+    redis-mpool "~0.4.1"
     underscore "~1.6.0"
 
 caseless@~0.12.0:
@@ -503,14 +488,10 @@ delegates@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/delegates/-/delegates-1.0.0.tgz#84c6e159b81904fdca59a0ef44cd870d31250f9a"
 
-depd@1.1.1:
+depd@1.1.1, depd@~1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/depd/-/depd-1.1.1.tgz#5783b4e1c459f06fa5ca27f991f3d06e7a310359"
 
-depd@~1.1.1:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/depd/-/depd-1.1.2.tgz#9bcd52e14c097763e749b274c4346ed2e560b5a9"
-
 destroy@~1.0.4:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/destroy/-/destroy-1.0.4.tgz#978857442c44749e4206613e37946205826abd80"
@@ -551,14 +532,14 @@ domutils@1.5:
     dom-serializer "0"
     domelementtype "1"
 
-dot@^1.0.3, dot@~1.0.2:
+dot@^1.0.3:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/dot/-/dot-1.1.2.tgz#c7377019fc4e550798928b2b9afeb66abfa1f2f9"
+
+dot@~1.0.2:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/dot/-/dot-1.0.3.tgz#f8750bfb6b03c7664eb0e6cb1eb4c66419af9427"
 
-double-ended-queue@^2.1.0-0:
-  version "2.1.0-0"
-  resolved "https://registry.yarnpkg.com/double-ended-queue/-/double-ended-queue-2.1.0-0.tgz#103d3527fd31528f40188130c841efdd78264e5c"
-
 dtrace-provider@~0.6:
   version "0.6.0"
   resolved "https://registry.yarnpkg.com/dtrace-provider/-/dtrace-provider-0.6.0.tgz#0b078d5517937d873101452d9146737557b75e51"
@@ -576,8 +557,8 @@ ee-first@1.1.1:
   resolved "https://registry.yarnpkg.com/ee-first/-/ee-first-1.1.1.tgz#590c61156b0ae2f4f0255732a158b266bc56b21d"
 
 encodeurl@~1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/encodeurl/-/encodeurl-1.0.2.tgz#ad3ff4c86ec2d029322f5a02c3a9a606c95b3f59"
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/encodeurl/-/encodeurl-1.0.1.tgz#79e3d58655346909fe6f0f45a5de68103b294d20"
 
 entities@1.0:
   version "1.0.0"
@@ -679,10 +660,14 @@ extend@~3.0.0, extend@~3.0.1:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.1.tgz#a755ea7bc1adfcc5a31ce7e762dbaadc5e636444"
 
-extsprintf@1.3.0, extsprintf@^1.2.0:
+extsprintf@1.3.0:
   version "1.3.0"
   resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.3.0.tgz#96918440e3041a7a414f8c52e3c574eb3c3e1e05"
 
+extsprintf@^1.2.0:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.4.0.tgz#e2689f8f356fad62cca65a3a91c5df5f9551692f"
+
 fast-deep-equal@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-1.0.0.tgz#96256a3bc975595eb36d82e9929d060d893439ff"
@@ -789,7 +774,7 @@ gdal@~0.9.2:
     nan "~2.6.2"
     node-pre-gyp "~0.6.36"
 
-generic-pool@2.4.3, generic-pool@~2.4.0, generic-pool@~2.4.1:
+generic-pool@2.4.3:
   version "2.4.3"
   resolved "https://registry.yarnpkg.com/generic-pool/-/generic-pool-2.4.3.tgz#780c36f69dfad05a5a045dd37be7adca11a4f6ff"
 
@@ -801,6 +786,10 @@ generic-pool@~2.2.0, generic-pool@~2.2.1:
   version "2.2.2"
   resolved "https://registry.yarnpkg.com/generic-pool/-/generic-pool-2.2.2.tgz#7a89f491d575b42f9f069a0e8e2c6dbaa3c241be"
 
+generic-pool@~2.4.0, generic-pool@~2.4.1:
+  version "2.4.6"
+  resolved "https://registry.yarnpkg.com/generic-pool/-/generic-pool-2.4.6.tgz#f1b55e572167dba2fe75d5aa91ebb1e9f72642d7"
+
 get-caller-file@^1.0.1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-1.0.2.tgz#f702e63127e7e231c160a80c1554acb70d5047e5"
@@ -861,9 +850,9 @@ graceful-fs@^4.1.2:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/graceful-readlink/-/graceful-readlink-1.0.1.tgz#4cafad76bc62f02fa039b2f94e9a3dd3a391a725"
 
-grainstore@1.8.2:
-  version "1.8.2"
-  resolved "https://registry.yarnpkg.com/grainstore/-/grainstore-1.8.2.tgz#79dd7a91a098bf8b0ea3189961775c8cc7474319"
+grainstore@~1.8.0:
+  version "1.8.0"
+  resolved "https://registry.yarnpkg.com/grainstore/-/grainstore-1.8.0.tgz#9398729df88f3aecb55ffbb415d541dcca4420af"
   dependencies:
     carto "0.16.3"
     debug "~3.1.0"
@@ -1092,8 +1081,8 @@ istanbul@~0.4.3:
     wordwrap "^1.0.0"
 
 js-base64@^2.1.9:
-  version "2.4.3"
-  resolved "https://registry.yarnpkg.com/js-base64/-/js-base64-2.4.3.tgz#2e545ec2b0f2957f41356510205214e98fad6582"
+  version "2.4.0"
+  resolved "https://registry.yarnpkg.com/js-base64/-/js-base64-2.4.0.tgz#9e566fee624751a1d720c966cd6226d29d4025aa"
 
 js-string-escape@1.0.1:
   version "1.0.1"
@@ -1251,8 +1240,8 @@ lodash@3.7.x:
   resolved "https://registry.yarnpkg.com/lodash/-/lodash-3.7.0.tgz#3678bd8ab995057c07ade836ed2ef087da811d45"
 
 lodash@^4.5.1:
-  version "4.17.5"
-  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.5.tgz#99a92d65c0272debe8c96b6057bc8fbfa3bed511"
+  version "4.17.4"
+  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.4.tgz#78203a4d1c328ae1d86dca6460e369b57f4055ae"
 
 log4js@cartodb/log4js-node#cdb:
   version "0.6.25"
@@ -1292,9 +1281,18 @@ mapnik-reference@~8.5.3:
   dependencies:
     semver "^5.1.0"
 
-mapnik-vector-tile@1.5.0:
-  version "1.5.0"
-  resolved "https://registry.yarnpkg.com/mapnik-vector-tile/-/mapnik-vector-tile-1.5.0.tgz#c647bfb8027e9dc40db583505a436f35e2101407"
+mapnik-vector-tile@~1.2.2:
+  version "1.2.2"
+  resolved "https://registry.yarnpkg.com/mapnik-vector-tile/-/mapnik-vector-tile-1.2.2.tgz#42795ca211dd274a9a4af5bf6cfe3b0bfe0ba243"
+
+mapnik@3.5.14, mapnik@~3.5.0:
+  version "3.5.14"
+  resolved "https://registry.yarnpkg.com/mapnik/-/mapnik-3.5.14.tgz#632bd6635c72c0214a707549309ba416594afff7"
+  dependencies:
+    mapnik-vector-tile "~1.2.2"
+    nan "~2.4.0"
+    node-pre-gyp "~0.6.30"
+    protozero "~1.4.2"
 
 media-typer@0.3.0:
   version "0.3.0"
@@ -1341,9 +1339,9 @@ mime@~1.2.11:
   version "1.2.11"
   resolved "https://registry.yarnpkg.com/mime/-/mime-1.2.11.tgz#58203eed86e3a5ef17aed2b7d9ebd47f0a60dd10"
 
-mime@~1.6.0:
-  version "1.6.0"
-  resolved "https://registry.yarnpkg.com/mime/-/mime-1.6.0.tgz#32cd9e5c64553bd58d19a568af452acff04981b1"
+mime@~1.3.4:
+  version "1.3.6"
+  resolved "https://registry.yarnpkg.com/mime/-/mime-1.3.6.tgz#591d84d3653a6b0b4a3b9df8de5aa8108e72e5e0"
 
 "minimatch@2 || 3", minimatch@^3.0.0, minimatch@^3.0.2, minimatch@^3.0.4, minimatch@~3.0.2:
   version "3.0.4"
@@ -1351,7 +1349,7 @@ mime@~1.6.0:
   dependencies:
     brace-expansion "^1.1.7"
 
-minimist@0.0.8, minimist@~0.0.1:
+minimist@0.0.8:
   version "0.0.8"
   resolved "https://registry.yarnpkg.com/minimist/-/minimist-0.0.8.tgz#857fcabfc3397d2625b8228262e86aa7a011b05d"
 
@@ -1359,6 +1357,10 @@ minimist@^1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.0.tgz#a35008b20f41383eec1fb914f4cd5df79a264284"
 
+minimist@~0.0.1:
+  version "0.0.10"
+  resolved "https://registry.yarnpkg.com/minimist/-/minimist-0.0.10.tgz#de3f98543dbf96082be48ad1a0c7cda836301dcf"
+
 minimist@~0.2.0:
   version "0.2.0"
   resolved "https://registry.yarnpkg.com/minimist/-/minimist-0.2.0.tgz#4dffe525dae2b864c66c2e23c6271d7afdecefce"
@@ -1385,7 +1387,11 @@ mocha@~3.4.1:
     mkdirp "0.5.1"
     supports-color "3.1.2"
 
-moment@^2.10.6, moment@~2.18.1:
+moment@^2.10.6:
+  version "2.22.2"
+  resolved "https://registry.yarnpkg.com/moment/-/moment-2.22.2.tgz#3c257f9839fc0e93ff53149632239eb90783ff66"
+
+moment@~2.18.1:
   version "2.18.1"
   resolved "https://registry.yarnpkg.com/moment/-/moment-2.18.1.tgz#c36193dd3ce1c2eed2adb7c802dbbc77a81b1c0f"
 
@@ -1405,7 +1411,11 @@ mv@~2:
     ncp "~2.0.0"
     rimraf "~2.4.0"
 
-nan@^2.0.8, nan@^2.3.4, nan@^2.4.0:
+nan@^2.0.8:
+  version "2.10.0"
+  resolved "https://registry.yarnpkg.com/nan/-/nan-2.10.0.tgz#96d0cd610ebd58d4b4de9cc0c6828cda99c7548f"
+
+nan@^2.3.4, nan@^2.4.0:
   version "2.8.0"
   resolved "https://registry.yarnpkg.com/nan/-/nan-2.8.0.tgz#ed715f3fe9de02b57a5e6252d90a96675e1f085a"
 
@@ -1499,10 +1509,14 @@ oauth-sign@~0.8.1, oauth-sign@~0.8.2:
   version "0.8.2"
   resolved "https://registry.yarnpkg.com/oauth-sign/-/oauth-sign-0.8.2.tgz#46a6ab7f0aead8deae9ec0565780b7d4efeb9d43"
 
-object-assign@4.1.0, object-assign@^4.1.0:
+object-assign@4.1.0:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.0.tgz#7a3b3d0e98063d43f4c03f2e8ae6cd51a86883a0"
 
+object-assign@^4.1.0:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
+
 object-keys@~0.4.0:
   version "0.4.0"
   resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-0.4.0.tgz#28a6aae7428dd2c3a92f3d95f21335dd204e0336"
@@ -1566,6 +1580,10 @@ packet-reader@0.2.0:
   version "0.2.0"
   resolved "https://registry.yarnpkg.com/packet-reader/-/packet-reader-0.2.0.tgz#819df4d010b82d5ea5671f8a1a3acf039bcd7700"
 
+packet-reader@0.3.1:
+  version "0.3.1"
+  resolved "https://registry.yarnpkg.com/packet-reader/-/packet-reader-0.3.1.tgz#cd62e60af8d7fea8a705ec4ff990871c46871f27"
+
 parse-json@^2.2.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-2.2.0.tgz#f480f40434ef80741f8469099f8dea18f55a4dc9"
@@ -1644,7 +1662,20 @@ pg@cartodb/node-postgres#6.1.6-cdb1:
     pgpass "1.x"
     semver "4.3.2"
 
-pgpass@1.x:
+"pg@github:CartoDB/node-postgres#6.4.2-cdb1":
+  version "6.4.2"
+  resolved "https://codeload.github.com/CartoDB/node-postgres/tar.gz/449fac1d6da711ffcc6694ae3c89f85244f48bdc"
+  dependencies:
+    buffer-writer "1.0.1"
+    js-string-escape "1.0.1"
+    packet-reader "0.3.1"
+    pg-connection-string "0.1.3"
+    pg-pool "1.*"
+    pg-types "1.*"
+    pgpass "1.*"
+    semver "4.3.2"
+
+pgpass@1.*, pgpass@1.x:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/pgpass/-/pgpass-1.0.2.tgz#2a7bb41b6065b67907e91da1b07c1847c877b306"
   dependencies:
@@ -1735,9 +1766,9 @@ propagate@0.3.x:
   version "0.3.1"
   resolved "https://registry.yarnpkg.com/propagate/-/propagate-0.3.1.tgz#e3a84404a7ece820dd6bbea9f6d924e3135ae09c"
 
-protozero@1.5.1:
-  version "1.5.1"
-  resolved "https://registry.yarnpkg.com/protozero/-/protozero-1.5.1.tgz#5a27df6fb6e1ed743f510812ae76c082f5b16638"
+protozero@~1.4.2:
+  version "1.4.5"
+  resolved "https://registry.yarnpkg.com/protozero/-/protozero-1.4.5.tgz#80eaa80a4f9c751465c4cb2620d8233b50ec1aff"
 
 proxy-addr@~2.0.2:
   version "2.0.2"
@@ -1776,8 +1807,8 @@ raw-body@2.3.2:
     unpipe "1.0.0"
 
 rc@^1.1.7:
-  version "1.2.5"
-  resolved "https://registry.yarnpkg.com/rc/-/rc-1.2.5.tgz#275cd687f6e3b36cc756baa26dfee80a790301fd"
+  version "1.2.2"
+  resolved "https://registry.yarnpkg.com/rc/-/rc-1.2.2.tgz#d8ce9cb57e8d64d9c7badd9876c7c34cbe3c7077"
   dependencies:
     deep-extend "~0.4.0"
     ini "~1.3.0"
@@ -1799,7 +1830,7 @@ read-pkg@^1.0.0:
     normalize-package-data "^2.3.2"
     path-type "^1.0.0"
 
-readable-stream@1.1, readable-stream@~1.1.9:
+readable-stream@1.1:
   version "1.1.13"
   resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-1.1.13.tgz#f6eef764f514c89e2b9e23146a75ba106756d23e"
   dependencies:
@@ -1829,30 +1860,27 @@ readable-stream@~1.0.2:
     isarray "0.0.1"
     string_decoder "~0.10.x"
 
-redis-commands@^1.2.0:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/redis-commands/-/redis-commands-1.3.1.tgz#81d826f45fa9c8b2011f4cd7a0fe597d241d442b"
+readable-stream@~1.1.9:
+  version "1.1.14"
+  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-1.1.14.tgz#7cf4c54ef648e3813084c636dd2079e166c081d9"
+  dependencies:
+    core-util-is "~1.0.0"
+    inherits "~2.0.1"
+    isarray "0.0.1"
+    string_decoder "~0.10.x"
 
-redis-mpool@0.5.0, redis-mpool@^0.5.0:
-  version "0.5.0"
-  resolved "https://registry.yarnpkg.com/redis-mpool/-/redis-mpool-0.5.0.tgz#9a22dcffb4ad796ec88ce3038b991deae9d1fda7"
+redis-mpool@0.4.1, redis-mpool@~0.4.1:
+  version "0.4.1"
+  resolved "https://registry.yarnpkg.com/redis-mpool/-/redis-mpool-0.4.1.tgz#d917c0a4ed57a1291a9c6eb35434e6c0b7046f80"
   dependencies:
     generic-pool "~2.1.1"
     hiredis "~0.5.0"
-    redis "^2.8.0"
+    redis "~0.12.1"
     underscore "~1.6.0"
 
-redis-parser@^2.6.0:
-  version "2.6.0"
-  resolved "https://registry.yarnpkg.com/redis-parser/-/redis-parser-2.6.0.tgz#52ed09dacac108f1a631c07e9b69941e7a19504b"
-
-redis@2.8.0, redis@^2.8.0:
-  version "2.8.0"
-  resolved "https://registry.yarnpkg.com/redis/-/redis-2.8.0.tgz#202288e3f58c49f6079d97af7a10e1303ae14b02"
-  dependencies:
-    double-ended-queue "^2.1.0-0"
-    redis-commands "^1.2.0"
-    redis-parser "^2.6.0"
+redis@~0.12.1:
+  version "0.12.1"
+  resolved "https://registry.yarnpkg.com/redis/-/redis-0.12.1.tgz#64df76ad0fc8acebaebd2a0645e8a48fac49185e"
 
 repeat-string@^1.5.2:
   version "1.6.1"
@@ -1912,7 +1940,7 @@ request@2.85.0:
     tunnel-agent "^0.6.0"
     uuid "^3.1.0"
 
-request@2.x, request@^2.55.0:
+request@2.x, request@^2.55.0, request@^2.83.0:
   version "2.83.0"
   resolved "https://registry.yarnpkg.com/request/-/request-2.83.0.tgz#ca0b65da02ed62935887808e6f510381034e3356"
   dependencies:
@@ -1974,12 +2002,12 @@ safe-buffer@5.1.1, safe-buffer@^5.0.1, safe-buffer@^5.1.1, safe-buffer@~5.1.0, s
   resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.1.tgz#893312af69b2123def71f57889001671eeb2c853"
 
 safe-json-stringify@~1:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/safe-json-stringify/-/safe-json-stringify-1.0.4.tgz#81a098f447e4bbc3ff3312a243521bc060ef5911"
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/safe-json-stringify/-/safe-json-stringify-1.2.0.tgz#356e44bc98f1f93ce45df14bcd7c01cda86e0afd"
 
-"semver@2 || 3 || 4 || 5", semver@^5.1.0, semver@^5.3.0, semver@~5.3.0:
-  version "5.3.0"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-5.3.0.tgz#9b2ce5d3de02d17c6012ad326aa6b4d0cf54f94f"
+"semver@2 || 3 || 4 || 5", semver@^5.1.0, semver@^5.3.0:
+  version "5.4.1"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-5.4.1.tgz#e059c09d8571f0540823733433505d3a2f00b18e"
 
 semver@4.3.2:
   version "4.3.2"
@@ -1993,6 +2021,10 @@ semver@~5.0.3:
   version "5.0.3"
   resolved "https://registry.yarnpkg.com/semver/-/semver-5.0.3.tgz#77466de589cd5d3c95f138aa78bc569a3cb5d27a"
 
+semver@~5.3.0:
+  version "5.3.0"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-5.3.0.tgz#9b2ce5d3de02d17c6012ad326aa6b4d0cf54f94f"
+
 send@0.16.1:
   version "0.16.1"
   resolved "https://registry.yarnpkg.com/send/-/send-0.16.1.tgz#a70e1ca21d1382c11d0d9f6231deb281080d7ab3"
@@ -2090,10 +2122,14 @@ speedometer@~0.1.2:
   version "0.1.4"
   resolved "https://registry.yarnpkg.com/speedometer/-/speedometer-0.1.4.tgz#9876dbd2a169d3115402d48e6ea6329c8816a50d"
 
-sphericalmercator@1.0.4, sphericalmercator@1.0.x, sphericalmercator@~1.0.1, sphericalmercator@~1.0.4:
+sphericalmercator@1.0.4:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/sphericalmercator/-/sphericalmercator-1.0.4.tgz#baad4e34187f06e87f2e92fc1280199fa1b01d4e"
 
+sphericalmercator@1.0.x, sphericalmercator@~1.0.1, sphericalmercator@~1.0.4:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/sphericalmercator/-/sphericalmercator-1.0.5.tgz#ddc5a049e360e000d0fad9fc22c4071882584980"
+
 split@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/split/-/split-1.0.1.tgz#605bd9be303aa59fb35f9229fbea0ddec9ea07d9"
@@ -2131,7 +2167,11 @@ sshpk@^1.7.0:
     jsbn "~0.1.0"
     tweetnacl "~0.14.0"
 
-"statuses@>= 1.3.1 < 2", statuses@~1.3.1:
+"statuses@>= 1.3.1 < 2":
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/statuses/-/statuses-1.4.0.tgz#bb73d446da2796106efcc1b601a253d6c46bd087"
+
+statuses@~1.3.1:
   version "1.3.1"
   resolved "https://registry.yarnpkg.com/statuses/-/statuses-1.3.1.tgz#faf51b9eb74aaef3b3acf4ad5f61abf24cb7b93e"
 
@@ -2239,13 +2279,21 @@ through@2:
   version "2.3.8"
   resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
 
-tilelive-mapnik@cartodb/tilelive-mapnik#0.6.18-cdb8:
-  version "0.6.18-cdb8"
-  resolved "https://codeload.github.com/cartodb/tilelive-mapnik/tar.gz/9cb4546c8fdd34ced0a41dbf70e143475b4e2067"
+tilelive-bridge@cartodb/tilelive-bridge#2.3.1-cdb4:
+  version "2.3.1-cdb4"
+  resolved "https://codeload.github.com/cartodb/tilelive-bridge/tar.gz/faa2b638da2d119b78281575d40255cb523f6ca6"
+  dependencies:
+    mapnik "~3.5.0"
+    mapnik-pool "~0.1.3"
+    sphericalmercator "1.0.x"
+
+tilelive-mapnik@cartodb/tilelive-mapnik#0.6.18-cdb3:
+  version "0.6.18-cdb3"
+  resolved "https://codeload.github.com/cartodb/tilelive-mapnik/tar.gz/23bd1c31dd57d0b76c86b9f1eaf62462b3c17d01"
   dependencies:
-    "@carto/mapnik" "3.6.2-carto.4"
     generic-pool "~2.4.0"
-    mime "~1.6.0"
+    mapnik "3.5.14"
+    mime "~1.3.4"
     sphericalmercator "~1.0.4"
     step "~0.0.5"
 
@@ -2354,8 +2402,8 @@ utils-merge@1.0.1:
   resolved "https://registry.yarnpkg.com/utils-merge/-/utils-merge-1.0.1.tgz#9f95710f50a267947b2ccc124741c1028427e713"
 
 uuid@^3.0.0, uuid@^3.1.0:
-  version "3.2.1"
-  resolved "https://registry.yarnpkg.com/uuid/-/uuid-3.2.1.tgz#12c528bb9d58d0b9265d9a2f6f0fe8be17ff1f14"
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/uuid/-/uuid-3.1.0.tgz#3dd3d3e790abc24d7b0d3a034ffababe28ebbc04"
 
 validate-npm-package-license@^3.0.1:
   version "3.0.1"
@@ -2400,27 +2448,27 @@ window-size@^0.2.0:
   version "0.2.0"
   resolved "https://registry.yarnpkg.com/window-size/-/window-size-0.2.0.tgz#b4315bb4214a3d7058ebeee892e13fa24d98b075"
 
-windshaft@4.6.0:
-  version "4.6.0"
-  resolved "https://registry.yarnpkg.com/windshaft/-/windshaft-4.6.0.tgz#d9394aff73c0aa761207ad2b0f12d1c23ac41244"
+windshaft@4.2.0:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/windshaft/-/windshaft-4.2.0.tgz#6a0409832a0d3bccfa09a88a8ab8288686b6762d"
   dependencies:
-    "@carto/mapnik" "3.6.2-carto.4"
-    "@carto/tilelive-bridge" cartodb/tilelive-bridge#2.5.1-cdb4
-    abaculus cartodb/abaculus#2.0.3-cdb5
+    abaculus cartodb/abaculus#2.0.3-cdb1
     canvas cartodb/node-canvas#1.6.2-cdb2
     carto cartodb/carto#0.15.1-cdb3
     cartodb-psql "^0.10.1"
     debug "^3.1.0"
     dot "~1.0.2"
-    grainstore "1.8.2"
+    grainstore "~1.8.0"
+    mapnik "3.5.14"
     queue-async "~1.0.7"
-    redis-mpool "^0.5.0"
-    request "2.85.0"
+    redis-mpool "0.4.1"
+    request "^2.83.0"
     semver "~5.0.3"
     sphericalmercator "1.0.4"
     step "~0.0.6"
     tilelive "5.12.2"
-    tilelive-mapnik cartodb/tilelive-mapnik#0.6.18-cdb8
+    tilelive-bridge cartodb/tilelive-bridge#2.3.1-cdb4
+    tilelive-mapnik cartodb/tilelive-mapnik#0.6.18-cdb3
     torque.js "~2.11.0"
     underscore "~1.6.0"