Merge branch 'master' into fix-image-format-png

lib/cartodb/api/api-router.js

@@ -191,7 +191,7 @@ module.exports = class ApiRouter {
         Object.keys(this.serverOptions.routes).forEach(apiVersion => {
             const routes = this.serverOptions.routes[apiVersion];
 
-            const apiRouter = router();
+            const apiRouter = router({ mergeParams: true });
 
             apiRouter.use(logger(this.serverOptions));
             apiRouter.use(initializeStatusCode());

lib/cartodb/api/map/analyses-catalog-controller.js

@@ -8,17 +8,19 @@ const { RATE_LIMIT_ENDPOINTS_GROUPS } = rateLimit;
 const cacheControlHeader = require('../middlewares/cache-control-header');
 const dbParamsFromResLocals = require('../../utils/database-params');
 
-function AnalysesController(pgConnection, authBackend, userLimitsBackend) {
+module.exports = class AnalysesController {
+    constructor (pgConnection, authBackend, userLimitsBackend) {
         this.pgConnection = pgConnection;
         this.authBackend = authBackend;
         this.userLimitsBackend = userLimitsBackend;
     }
 
-module.exports = AnalysesController;
+    register (mapRouter) {
+        mapRouter.get('/analyses/catalog', this.middlewares());
+    }
 
-AnalysesController.prototype.register = function (mapRouter) {
+    middlewares () {
-    mapRouter.get(
+        return [
-        `/analyses/catalog`,
             credentials(),
             authorize(this.authBackend),
             dbConnSetup(this.pgConnection),
@@ -30,7 +32,8 @@ AnalysesController.prototype.register = function (mapRouter) {
             prepareResponse(),
             cacheControlHeader({ ttl: 10, revalidate: true }),
             unauthorizedError()
-    );
+        ];
+    }
 };
 
 function createPGClient () {

lib/cartodb/api/map/analysis-layergroup-controller.js

@@ -16,8 +16,11 @@ module.exports = class AnalysisLayergroupController {
     }
 
     register (mapRouter) {
-        mapRouter.get(
+        mapRouter.get('/:token/analysis/node/:nodeId', this.middlewares());
-            `/:token/analysis/node/:nodeId`,
+    }
+
+    middlewares () {
+        return [
             layergroupToken(),
             credentials(),
             authorize(this.authBackend),
@@ -25,8 +28,7 @@ module.exports = class AnalysisLayergroupController {
             rateLimit(this.userLimitsBackend, RATE_LIMIT_ENDPOINTS_GROUPS.ANALYSIS),
             cleanUpQueryParams(),
             analysisNodeStatus(this.analysisStatusBackend)
-        );
+        ];
-
     }
 };
 

lib/cartodb/api/map/anonymous-map-controller.js

@@ -22,6 +22,7 @@ const CreateLayergroupMapConfigProvider = require('../../models/mapconfig/provid
 const rateLimit = require('../middlewares/rate-limit');
 const { RATE_LIMIT_ENDPOINTS_GROUPS } = rateLimit;
 
+module.exports = class AnonymousMapController {
     /**
      * @param {AuthBackend} authBackend
      * @param {PgConnection} pgConnection
@@ -35,7 +36,7 @@ const { RATE_LIMIT_ENDPOINTS_GROUPS } = rateLimit;
      * @param {StatsBackend} statsBackend
      * @constructor
      */
-function AnonymousMapController (
+    constructor (
         pgConnection,
         templateMaps,
         mapBackend,
@@ -61,15 +62,13 @@ function AnonymousMapController (
         this.layergroupMetadata = layergroupMetadata;
     }
 
-module.exports = AnonymousMapController;
+    register (mapRouter) {
-
-AnonymousMapController.prototype.register = function (mapRouter) {
         mapRouter.options('/');
-    mapRouter.get('/', this.composeCreateMapMiddleware());
+        mapRouter.get('/', this.middlewares());
-    mapRouter.post('/', this.composeCreateMapMiddleware());
+        mapRouter.post('/', this.middlewares());
-};
+    }
 
-AnonymousMapController.prototype.composeCreateMapMiddleware = function () {
+    middlewares () {
         const isTemplateInstantiation = false;
         const useTemplateHash = false;
         const includeQuery = true;
@@ -104,6 +103,7 @@ AnonymousMapController.prototype.composeCreateMapMiddleware = function () {
             layergroupMetadata(this.layergroupMetadata, includeQuery),
             mapError({ label, addContext })
         ];
+    }
 };
 
 function checkCreateLayergroup () {

lib/cartodb/api/map/attributes-layergroup-controller.js

@@ -31,8 +31,11 @@ module.exports = class AttributesLayergroupController {
     }
 
     register (mapRouter) {
-        mapRouter.get(
+        mapRouter.get('/:token/:layer/attributes/:fid', this.middlewares());
-            `/:token/:layer/attributes/:fid`,
+    }
+
+    middlewares () {
+        return [
             layergroupToken(),
             credentials(),
             authorize(this.authBackend),
@@ -50,7 +53,7 @@ module.exports = class AttributesLayergroupController {
             cacheChannelHeader(),
             surrogateKeyHeader({ surrogateKeysCache: this.surrogateKeysCache }),
             lastModifiedHeader()
-        );
+        ];
     }
 };
 

lib/cartodb/api/map/dataview-layergroup-controller.js

@@ -49,76 +49,34 @@ module.exports = class DataviewLayergroupController {
         // Undocumented/non-supported API endpoint methods.
         // Use at your own peril.
 
-        mapRouter.get(
+        mapRouter.get('/:token/dataview/:dataviewName', this.middlewares({
-            `/:token/dataview/:dataviewName`,
+            action: 'get',
-            layergroupToken(),
+            rateLimitGroup: RATE_LIMIT_ENDPOINTS_GROUPS.DATAVIEW
-            credentials(),
+        }));
-            authorize(this.authBackend),
-            dbConnSetup(this.pgConnection),
-            rateLimit(this.userLimitsBackend, RATE_LIMIT_ENDPOINTS_GROUPS.DATAVIEW),
-            cleanUpQueryParams(ALLOWED_DATAVIEW_QUERY_PARAMS),
-            createMapStoreMapConfigProvider(
-                this.mapStore,
-                this.userLimitsBackend,
-                this.pgConnection,
-                this.layergroupAffectedTablesCache
-            ),
-            getDataview(this.dataviewBackend),
-            cacheControlHeader(),
-            cacheChannelHeader(),
-            surrogateKeyHeader({ surrogateKeysCache: this.surrogateKeysCache }),
-            lastModifiedHeader()
-        );
 
-        mapRouter.get(
+        mapRouter.get('/:token/:layer/widget/:dataviewName', this.middlewares({
-            `/:token/:layer/widget/:dataviewName`,
+            action: 'get',
-            layergroupToken(),
+            rateLimitGroup: RATE_LIMIT_ENDPOINTS_GROUPS.DATAVIEW
-            credentials(),
+        }));
-            authorize(this.authBackend),
-            dbConnSetup(this.pgConnection),
-            rateLimit(this.userLimitsBackend, RATE_LIMIT_ENDPOINTS_GROUPS.DATAVIEW),
-            cleanUpQueryParams(ALLOWED_DATAVIEW_QUERY_PARAMS),
-            createMapStoreMapConfigProvider(
-                this.mapStore,
-                this.userLimitsBackend,
-                this.pgConnection,
-                this.layergroupAffectedTablesCache
-            ),
-            getDataview(this.dataviewBackend),
-            cacheControlHeader(),
-            cacheChannelHeader(),
-            surrogateKeyHeader({ surrogateKeysCache: this.surrogateKeysCache }),
-            lastModifiedHeader()
-        );
 
-        mapRouter.get(
+        mapRouter.get('/:token/dataview/:dataviewName/search', this.middlewares({
-            `/:token/dataview/:dataviewName/search`,
+            action: 'search',
-            layergroupToken(),
+            rateLimitGroup: RATE_LIMIT_ENDPOINTS_GROUPS.DATAVIEW_SEARCH
-            credentials(),
+        }));
-            authorize(this.authBackend),
-            dbConnSetup(this.pgConnection),
-            rateLimit(this.userLimitsBackend, RATE_LIMIT_ENDPOINTS_GROUPS.DATAVIEW_SEARCH),
-            cleanUpQueryParams(ALLOWED_DATAVIEW_QUERY_PARAMS),
-            createMapStoreMapConfigProvider(
-                this.mapStore,
-                this.userLimitsBackend,
-                this.pgConnection,
-                this.layergroupAffectedTablesCache
-            ),
-            dataviewSearch(this.dataviewBackend),
-            cacheControlHeader(),
-            cacheChannelHeader(),
-            surrogateKeyHeader({ surrogateKeysCache: this.surrogateKeysCache }),
-            lastModifiedHeader()
-        );
 
-        mapRouter.get(
+        mapRouter.get('/:token/:layer/widget/:dataviewName/search', this.middlewares({
-            `/:token/:layer/widget/:dataviewName/search`,
+            action: 'search',
+            rateLimitGroup: RATE_LIMIT_ENDPOINTS_GROUPS.DATAVIEW_SEARCH
+        }));
+    }
+
+    middlewares ({ action, rateLimitGroup }) {
+        return [
             layergroupToken(),
             credentials(),
             authorize(this.authBackend),
             dbConnSetup(this.pgConnection),
-            rateLimit(this.userLimitsBackend, RATE_LIMIT_ENDPOINTS_GROUPS.DATAVIEW_SEARCH),
+            rateLimit(this.userLimitsBackend, rateLimitGroup),
             cleanUpQueryParams(ALLOWED_DATAVIEW_QUERY_PARAMS),
             createMapStoreMapConfigProvider(
                 this.mapStore,
@@ -126,12 +84,12 @@ module.exports = class DataviewLayergroupController {
                 this.pgConnection,
                 this.layergroupAffectedTablesCache
             ),
-            dataviewSearch(this.dataviewBackend),
+            action === 'search' ? dataviewSearch(this.dataviewBackend) : getDataview(this.dataviewBackend),
             cacheControlHeader(),
             cacheChannelHeader(),
             surrogateKeyHeader({ surrogateKeysCache: this.surrogateKeysCache }),
             lastModifiedHeader()
-        );
+        ];
     }
 };
 

lib/cartodb/api/map/map-router.js

@@ -113,7 +113,7 @@ module.exports = class MapRouter {
     }
 
     register (apiRouter, mapPaths) {
-        const mapRouter = router();
+        const mapRouter = router({ mergeParams: true });
 
         this.analysisLayergroupController.register(mapRouter);
         this.attributesLayergroupController.register(mapRouter);

lib/cartodb/api/map/preview-layergroup-controller.js

@@ -2,6 +2,7 @@ const layergroupToken = require('../middlewares/layergroup-token');
 const coordinates = require('../middlewares/coordinates');
 const cleanUpQueryParams = require('../middlewares/clean-up-query-params');
 const credentials = require('../middlewares/credentials');
+const noop = require('../middlewares/noop');
 const dbConnSetup = require('../middlewares/db-conn-setup');
 const authorize = require('../middlewares/authorize');
 const rateLimit = require('../middlewares/rate-limit');
@@ -33,35 +34,33 @@ module.exports = class PreviewLayergroupController {
     }
 
     register (mapRouter) {
+        mapRouter.get('/static/center/:token/:z/:lat/:lng/:width/:height.:format', this.middlewares({
+            validateZoom: true,
+            previewType: 'centered'
+        }));
+
+        mapRouter.get('/static/bbox/:token/:west,:south,:east,:north/:width/:height.:format', this.middlewares({
+            validateZoom: false,
+            previewType: 'bbox'
+        }));
+    }
+
+    middlewares ({ validateZoom, previewType }) {
         const forcedFormat = 'png';
 
-        mapRouter.get(
+        let getPreviewImage;
-            `/static/center/:token/:z/:lat/:lng/:width/:height.:format`,
-            layergroupToken(),
-            coordinates({ z: true, x: false, y: false }),
-            credentials(),
-            authorize(this.authBackend),
-            dbConnSetup(this.pgConnection),
-            rateLimit(this.userLimitsBackend, RATE_LIMIT_ENDPOINTS_GROUPS.STATIC),
-            cleanUpQueryParams(['layer']),
-            checkStaticImageFormat(),
-            createMapStoreMapConfigProvider(
-                this.mapStore,
-                this.userLimitsBackend,
-                this.pgConnection,
-                this.layergroupAffectedTablesCache,
-                forcedFormat
-            ),
-            getPreviewImageByCenter(this.previewBackend),
-            cacheControlHeader(),
-            cacheChannelHeader(),
-            surrogateKeyHeader({ surrogateKeysCache: this.surrogateKeysCache }),
-            lastModifiedHeader()
-        );
 
-        mapRouter.get(
+        if (previewType === 'centered') {
-            `/static/bbox/:token/:west,:south,:east,:north/:width/:height.:format`,
+            getPreviewImage = getPreviewImageByCenter;
+        }
+
+        if (previewType === 'bbox') {
+            getPreviewImage = getPreviewImageByBoundingBox;
+        }
+
+        return [
             layergroupToken(),
+            validateZoom ? coordinates({ z: true, x: false, y: false }) : noop(),
             credentials(),
             authorize(this.authBackend),
             dbConnSetup(this.pgConnection),
@@ -75,12 +74,12 @@ module.exports = class PreviewLayergroupController {
                 this.layergroupAffectedTablesCache,
                 forcedFormat
             ),
-            getPreviewImageByBoundingBox(this.previewBackend),
+            getPreviewImage(this.previewBackend),
             cacheControlHeader(),
             cacheChannelHeader(),
             surrogateKeyHeader({ surrogateKeysCache: this.surrogateKeysCache }),
             lastModifiedHeader()
-        );
+        ];
     }
 };
 

lib/cartodb/api/map/preview-template-controller.js

@@ -23,7 +23,8 @@ function numMapper(n) {
     return +n;
 }
 
-function PreviewTemplateController (
+module.exports = class PreviewTemplateController {
+    constructor (
         namedMapProviderCache,
         previewBackend,
         surrogateKeysCache,
@@ -43,11 +44,12 @@ function PreviewTemplateController (
         this.userLimitsBackend = userLimitsBackend;
     }
 
-module.exports = PreviewTemplateController;
+    register (mapRouter) {
+        mapRouter.get('/static/named/:template_id/:width/:height.:format', this.middlewares());
+    }
 
-PreviewTemplateController.prototype.register = function (mapRouter) {
+    middlewares () {
-    mapRouter.get(
+        return [
-        `/static/named/:template_id/:width/:height.:format`,
             credentials(),
             authorize(this.authBackend),
             dbConnSetup(this.pgConnection),
@@ -71,7 +73,8 @@ PreviewTemplateController.prototype.register = function (mapRouter) {
             cacheChannelHeader(),
             surrogateKeyHeader({ surrogateKeysCache: this.surrogateKeysCache }),
             lastModifiedHeader()
-    );
+        ];
+    }
 };
 
 function getTemplate ({ label }) {

lib/cartodb/api/map/tile-layergroup-controller.js

@@ -42,14 +42,21 @@ module.exports = class TileLayergroupController {
     }
 
     register (mapRouter) {
-        // REGEXP doesn't match with `val`
+        // REGEXP: doesn't match with `val`
         const not = (val) => `(?!${val})([^\/]+?)`;
 
+        // Sadly the path that matches 1 also matches with 2 so we need to tell to express
+        // that performs only the middlewares of the first path that matches
+        // for that we use one array to group all paths.
         mapRouter.get([
-                `/:token/:z/:x/:y@:scale_factor?x.:format`,
+            `/:token/:z/:x/:y@:scale_factor?x.:format`, // 1
-                `/:token/:z/:x/:y.:format`,
+            `/:token/:z/:x/:y.:format`, // 2
             `/:token${not('static')}/:layer/:z/:x/:y.(:format)`
-            ],
+        ], this.middlewares());
+    }
+
+    middlewares () {
+        return [
             layergroupToken(),
             coordinates(),
             credentials(),
@@ -72,7 +79,7 @@ module.exports = class TileLayergroupController {
             incrementErrorMetrics(global.statsClient),
             tileError(),
             vectorError()
-        );
+        ];
     }
 };
 

lib/cartodb/api/middlewares/noop.js

@@ -0,0 +1,5 @@
+module.exports = function noop () {
+    return function noopMiddleware (req, res, next) {
+        next();
+    };
+};

lib/cartodb/api/template/admin-template-controller.js

@@ -3,70 +3,90 @@ const credentials = require('../middlewares/credentials');
 const rateLimit = require('../middlewares/rate-limit');
 const { RATE_LIMIT_ENDPOINTS_GROUPS } = rateLimit;
 
+module.exports = class AdminTemplateController {
     /**
      * @param {AuthBackend} authBackend
      * @param {PgConnection} pgConnection
      * @param {TemplateMaps} templateMaps
      * @constructor
      */
-function AdminTemplateController(authBackend, templateMaps, userLimitsBackend) {
+    constructor (authBackend, templateMaps, userLimitsBackend) {
         this.authBackend = authBackend;
         this.templateMaps = templateMaps;
         this.userLimitsBackend = userLimitsBackend;
     }
 
-module.exports = AdminTemplateController;
+    register (templateRouter) {
-
-AdminTemplateController.prototype.register = function (templateRouter) {
         templateRouter.options(`/:template_id`);
 
-    templateRouter.post(
+        templateRouter.post('/', this.middlewares({
-        `/`,
+            action: 'create',
+            label: 'POST TEMPLATE',
+            rateLimitGroup: RATE_LIMIT_ENDPOINTS_GROUPS.NAMED_CREATE
+        }));
+
+        templateRouter.put('/:template_id', this.middlewares({
+            action: 'update',
+            label: 'PUT TEMPLATE',
+            rateLimitGroup: RATE_LIMIT_ENDPOINTS_GROUPS.NAMED_UPDATE
+        }));
+
+        templateRouter.get('/:template_id', this.middlewares({
+            action: 'get',
+            label: 'GET TEMPLATE',
+            rateLimitGroup: RATE_LIMIT_ENDPOINTS_GROUPS.NAMED_GET
+        }));
+
+        templateRouter.delete('/:template_id', this.middlewares({
+            action: 'delete',
+            label: 'DELETE TEMPLATE',
+            rateLimitGroup: RATE_LIMIT_ENDPOINTS_GROUPS.NAMED_DELETE
+        }));
+
+        templateRouter.get('/', this.middlewares({
+            action: 'list',
+            label: 'GET TEMPLATE LIST',
+            rateLimitGroup: RATE_LIMIT_ENDPOINTS_GROUPS.NAMED_LIST
+        }));
+    }
+
+    middlewares ({ action, label, rateLimitGroup }) {
+        let template;
+
+        if (action === 'create') {
+            template = createTemplate;
+        }
+
+        if (action === 'update') {
+            template = updateTemplate;
+        }
+
+        if (action === 'get') {
+            template = retrieveTemplate;
+        }
+
+        if (action === 'delete') {
+            template = destroyTemplate;
+        }
+
+        if (action === 'list') {
+            template = listTemplates;
+        }
+
+        return [
             credentials(),
-        authorizedByAPIKey({ authBackend: this.authBackend, action: 'create', label: 'POST TEMPLATE' }),
+            authorizedByAPIKey({ authBackend: this.authBackend, action, label }),
-        rateLimit(this.userLimitsBackend, RATE_LIMIT_ENDPOINTS_GROUPS.NAMED_CREATE),
+            rateLimit(this.userLimitsBackend, rateLimitGroup),
             checkContentType({ action: 'POST', label: 'POST TEMPLATE' }),
-        createTemplate({ templateMaps: this.templateMaps })
+            template({ templateMaps: this.templateMaps })
-    );
+        ];
-
+    }
-    templateRouter.put(
-        `/:template_id`,
-        credentials(),
-        authorizedByAPIKey({ authBackend: this.authBackend, action: 'update', label: 'PUT TEMPLATE' }),
-        rateLimit(this.userLimitsBackend, RATE_LIMIT_ENDPOINTS_GROUPS.NAMED_UPDATE),
-        checkContentType({ action: 'PUT', label: 'PUT TEMPLATE' }),
-        updateTemplate({ templateMaps: this.templateMaps })
-    );
-
-    templateRouter.get(
-        `/:template_id`,
-        credentials(),
-        authorizedByAPIKey({ authBackend: this.authBackend, action: 'get', label: 'GET TEMPLATE' }),
-        rateLimit(this.userLimitsBackend, RATE_LIMIT_ENDPOINTS_GROUPS.NAMED_GET),
-        retrieveTemplate({ templateMaps: this.templateMaps })
-    );
-
-    templateRouter.delete(
-        `/:template_id`,
-        credentials(),
-        authorizedByAPIKey({ authBackend: this.authBackend, action: 'delete', label: 'DELETE TEMPLATE' }),
-        rateLimit(this.userLimitsBackend, RATE_LIMIT_ENDPOINTS_GROUPS.NAMED_DELETE),
-        destroyTemplate({ templateMaps: this.templateMaps })
-    );
-
-    templateRouter.get(
-        `/`,
-        credentials(),
-        authorizedByAPIKey({ authBackend: this.authBackend, action: 'list', label: 'GET TEMPLATE LIST' }),
-        rateLimit(this.userLimitsBackend, RATE_LIMIT_ENDPOINTS_GROUPS.NAMED_LIST),
-        listTemplates({ templateMaps: this.templateMaps })
-    );
 };
 
-function checkContentType ({ action, label }) {
+function checkContentType ({ label }) {
     return function checkContentTypeMiddleware (req, res, next) {
-        if (!req.is('application/json')) {
+        if ((req.method === 'POST' || req.method === 'PUT') && !req.is('application/json')) {
-            const error = new Error(`template ${action} data must be of type application/json`);
+            const error = new Error(`${req.method} template data must be of type application/json`);
             error.label = label;
             return next(error);
         }

lib/cartodb/api/template/named-template-controller.js

@@ -20,8 +20,8 @@ const CreateLayergroupMapConfigProvider = require('../../models/mapconfig/provid
 const rateLimit = require('../middlewares/rate-limit');
 const { RATE_LIMIT_ENDPOINTS_GROUPS } = rateLimit;
 
+module.exports = class NamedMapController {
     /**
- * @param {AuthBackend} authBackend
      * @param {PgConnection} pgConnection
      * @param {TemplateMaps} templateMaps
      * @param {MapBackend} mapBackend
@@ -31,9 +31,11 @@ const { RATE_LIMIT_ENDPOINTS_GROUPS } = rateLimit;
      * @param {LayergroupAffectedTables} layergroupAffectedTables
      * @param {MapConfigAdapter} mapConfigAdapter
      * @param {StatsBackend} statsBackend
+     * @param {AuthBackend} authBackend
+     * @param layergroupMetadata
      * @constructor
      */
-function NamedMapController (
+    constructor (
         pgConnection,
         templateMaps,
         mapBackend,
@@ -59,21 +61,12 @@ function NamedMapController (
         this.layergroupMetadata = layergroupMetadata;
     }
 
-module.exports = NamedMapController;
+    register (templateRouter) {
+        templateRouter.get('/:template_id/jsonp', this.middlewares());
+        templateRouter.post('/:template_id', this.middlewares());
+    }
 
-NamedMapController.prototype.register = function (templateRouter) {
+    middlewares () {
-    templateRouter.get(
-        `/:template_id/jsonp`,
-        this.composeInstantiateTemplateMiddleware()
-    );
-
-    templateRouter.post(
-        `/:template_id`,
-        this.composeInstantiateTemplateMiddleware()
-    );
-};
-
-NamedMapController.prototype.composeInstantiateTemplateMiddleware = function () {
         const isTemplateInstantiation = true;
         const useTemplateHash = true;
         const includeQuery = false;
@@ -115,6 +108,7 @@ NamedMapController.prototype.composeInstantiateTemplateMiddleware = function ()
             layergroupMetadata(this.layergroupMetadata, includeQuery),
             mapError({ label, addContext })
         ];
+    }
 };
 
 function checkInstantiteLayergroup () {

lib/cartodb/api/template/template-router.js

@@ -53,7 +53,7 @@ module.exports = class TemplateRouter {
     }
 
     register (apiRouter, templatePaths) {
-        const templateRouter = router();
+        const templateRouter = router({ mergeParams: true });
 
         this.namedMapController.register(templateRouter);
         this.tileTemplateController.register(templateRouter);

lib/cartodb/api/template/tile-template-controller.js

@@ -12,7 +12,8 @@ const vectorError = require('../middlewares/vector-error');
 const rateLimit = require('../middlewares/rate-limit');
 const { RATE_LIMIT_ENDPOINTS_GROUPS } = rateLimit;
 
-function TileTemplateController (
+module.exports = class TileTemplateController {
+    constructor (
         namedMapProviderCache,
         tileBackend,
         surrogateKeysCache,
@@ -28,11 +29,12 @@ function TileTemplateController (
         this.userLimitsBackend = userLimitsBackend;
     }
 
-module.exports = TileTemplateController;
+    register (templateRouter) {
+        templateRouter.get('/:template_id/:layer/:z/:x/:y.(:format)', this.middlewares());
+    }
 
-TileTemplateController.prototype.register = function (templateRouter) {
+    middlewares () {
-    templateRouter.get(
+        return [
-        `/:template_id/:layer/:z/:x/:y.(:format)`,
             coordinates(),
             credentials(),
             authorize(this.authBackend),
@@ -53,7 +55,8 @@ TileTemplateController.prototype.register = function (templateRouter) {
             surrogateKeyHeader({ surrogateKeysCache: this.surrogateKeysCache }),
             lastModifiedHeader(),
             vectorError()
-    );
+        ];
+    }
 };
 
 function getTile ({ tileBackend, label }) {

test/acceptance/regressions.js

@@ -1,7 +1,10 @@
 require('../support/test_helper');
 var assert = require('../support/assert');
+const helper = require('../support/test_helper');
 var TestClient = require('../support/test-client');
 const LayergroupToken = require('../../lib/cartodb/models/layergroup-token');
+const CartodbWindshaft = require(__dirname + '/../../lib/cartodb/server');
+const serverOptions = require(__dirname + '/../../lib/cartodb/server_options');
 
 describe('regressions', function() {
 
@@ -38,6 +41,49 @@ describe('regressions', function() {
         });
     });
 
+    // See: https://github.com/CartoDB/Windshaft-cartodb/pull/956
+    it('"/user/localhost/api/v1/map" should create an anonymous map', function (done) {
+        const server = new CartodbWindshaft(serverOptions);
+        const layergroup = {
+            version: '1.7.0',
+            layers: [
+                {
+                    type: 'mapnik',
+                    options: {
+                        sql: TestClient.SQL.ONE_POINT,
+                        cartocss: TestClient.CARTOCSS.POINTS,
+                        cartocss_version: '2.3.0'
+                    }
+                }
+            ]
+        };
+
+        const keysToDelete = {};
+
+        assert.response(server,
+            {
+                url: '/user/localhost/api/v1/map',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                data: JSON.stringify(layergroup)
+            },
+            function(res, err) {
+                if (err) {
+                    return done(err);
+                }
+
+                const body = JSON.parse(res.body);
+                assert.ok(body.layergroupid);
+
+                keysToDelete['map_cfg|' + LayergroupToken.parse(body.layergroupid).token] = 0;
+                keysToDelete['user:localhost:mapviews:global'] = 5;
+                helper.deleteRedisKeys(keysToDelete, done);
+            }
+        );
+    });
+
     describe('map instantiation', function () {
         const apikeyToken = 'regular1';
         const mapConfig = {