Merge pull request #954 from CartoDB/controllers-goodies

Controllers goodies

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

@@ -8,29 +8,32 @@ const { RATE_LIMIT_ENDPOINTS_GROUPS } = rateLimit;
 const cacheControlHeader = require('../middlewares/cache-control-header');
 const dbParamsFromResLocals = require('../../utils/database-params');
 
-function AnalysesController(pgConnection, authBackend, userLimitsBackend) {
-    this.pgConnection = pgConnection;
-    this.authBackend = authBackend;
-    this.userLimitsBackend = 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) {
-    mapRouter.get(
-        `/analyses/catalog`,
-        credentials(),
-        authorize(this.authBackend),
-        dbConnSetup(this.pgConnection),
-        rateLimit(this.userLimitsBackend, RATE_LIMIT_ENDPOINTS_GROUPS.ANALYSIS_CATALOG),
-        cleanUpQueryParams(),
-        createPGClient(),
-        getDataFromQuery({ queryTemplate: catalogQueryTpl, key: 'catalog' }),
-        getDataFromQuery({ queryTemplate: tablesQueryTpl, key: 'tables' }),
-        prepareResponse(),
-        cacheControlHeader({ ttl: 10, revalidate: true }),
-        unauthorizedError()
-    );
+    middlewares () {
+        return [
+            credentials(),
+            authorize(this.authBackend),
+            dbConnSetup(this.pgConnection),
+            rateLimit(this.userLimitsBackend, RATE_LIMIT_ENDPOINTS_GROUPS.ANALYSIS_CATALOG),
+            cleanUpQueryParams(),
+            createPGClient(),
+            getDataFromQuery({ queryTemplate: catalogQueryTpl, key: 'catalog' }),
+            getDataFromQuery({ queryTemplate: tablesQueryTpl, key: 'tables' }),
+            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(
-            `/:token/analysis/node/:nodeId`,
+        mapRouter.get('/:token/analysis/node/:nodeId', this.middlewares());
+    }
+
+    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,88 +22,88 @@ const CreateLayergroupMapConfigProvider = require('../../models/mapconfig/provid
 const rateLimit = require('../middlewares/rate-limit');
 const { RATE_LIMIT_ENDPOINTS_GROUPS } = rateLimit;
 
-/**
- * @param {AuthBackend} authBackend
- * @param {PgConnection} pgConnection
- * @param {TemplateMaps} templateMaps
- * @param {MapBackend} mapBackend
- * @param metadataBackend
- * @param {SurrogateKeysCache} surrogateKeysCache
- * @param {UserLimitsBackend} userLimitsBackend
- * @param {LayergroupAffectedTables} layergroupAffectedTables
- * @param {MapConfigAdapter} mapConfigAdapter
- * @param {StatsBackend} statsBackend
- * @constructor
- */
-function AnonymousMapController (
-    pgConnection,
-    templateMaps,
-    mapBackend,
-    metadataBackend,
-    surrogateKeysCache,
-    userLimitsBackend,
-    layergroupAffectedTables,
-    mapConfigAdapter,
-    statsBackend,
-    authBackend,
-    layergroupMetadata
-) {
-    this.pgConnection = pgConnection;
-    this.templateMaps = templateMaps;
-    this.mapBackend = mapBackend;
-    this.metadataBackend = metadataBackend;
-    this.surrogateKeysCache = surrogateKeysCache;
-    this.userLimitsBackend = userLimitsBackend;
-    this.layergroupAffectedTables = layergroupAffectedTables;
-    this.mapConfigAdapter = mapConfigAdapter;
-    this.statsBackend = statsBackend;
-    this.authBackend = authBackend;
-    this.layergroupMetadata = layergroupMetadata;
-}
+module.exports = class AnonymousMapController {
+    /**
+     * @param {AuthBackend} authBackend
+     * @param {PgConnection} pgConnection
+     * @param {TemplateMaps} templateMaps
+     * @param {MapBackend} mapBackend
+     * @param metadataBackend
+     * @param {SurrogateKeysCache} surrogateKeysCache
+     * @param {UserLimitsBackend} userLimitsBackend
+     * @param {LayergroupAffectedTables} layergroupAffectedTables
+     * @param {MapConfigAdapter} mapConfigAdapter
+     * @param {StatsBackend} statsBackend
+     * @constructor
+     */
+    constructor (
+        pgConnection,
+        templateMaps,
+        mapBackend,
+        metadataBackend,
+        surrogateKeysCache,
+        userLimitsBackend,
+        layergroupAffectedTables,
+        mapConfigAdapter,
+        statsBackend,
+        authBackend,
+        layergroupMetadata
+    ) {
+        this.pgConnection = pgConnection;
+        this.templateMaps = templateMaps;
+        this.mapBackend = mapBackend;
+        this.metadataBackend = metadataBackend;
+        this.surrogateKeysCache = surrogateKeysCache;
+        this.userLimitsBackend = userLimitsBackend;
+        this.layergroupAffectedTables = layergroupAffectedTables;
+        this.mapConfigAdapter = mapConfigAdapter;
+        this.statsBackend = statsBackend;
+        this.authBackend = authBackend;
+        this.layergroupMetadata = layergroupMetadata;
+    }
 
-module.exports = AnonymousMapController;
+    register (mapRouter) {
+        mapRouter.options('/');
+        mapRouter.get('/', this.middlewares());
+        mapRouter.post('/', this.middlewares());
+    }
 
-AnonymousMapController.prototype.register = function (mapRouter) {
-    mapRouter.options('/');
-    mapRouter.get('/', this.composeCreateMapMiddleware());
-    mapRouter.post('/', this.composeCreateMapMiddleware());
-};
+    middlewares () {
+        const isTemplateInstantiation = false;
+        const useTemplateHash = false;
+        const includeQuery = true;
+        const label = 'ANONYMOUS LAYERGROUP';
+        const addContext = true;
 
-AnonymousMapController.prototype.composeCreateMapMiddleware = function () {
-    const isTemplateInstantiation = false;
-    const useTemplateHash = false;
-    const includeQuery = true;
-    const label = 'ANONYMOUS LAYERGROUP';
-    const addContext = true;
-
-    return [
-        credentials(),
-        authorize(this.authBackend),
-        dbConnSetup(this.pgConnection),
-        rateLimit(this.userLimitsBackend, RATE_LIMIT_ENDPOINTS_GROUPS.ANONYMOUS),
-        cleanUpQueryParams(['aggregation']),
-        initProfiler(isTemplateInstantiation),
-        checkJsonContentType(),
-        checkCreateLayergroup(),
-        prepareAdapterMapConfig(this.mapConfigAdapter),
-        createLayergroup (
-            this.mapBackend,
-            this.userLimitsBackend,
-            this.pgConnection,
-            this.layergroupAffectedTables
-        ),
-        incrementMapViewCount(this.metadataBackend),
-        augmentLayergroupData(),
-        cacheControlHeader({ ttl: global.environment.varnish.layergroupTtl || 86400, revalidate: true }),
-        cacheChannelHeader(),
-        surrogateKeyHeader({ surrogateKeysCache: this.surrogateKeysCache }),
-        lastModifiedHeader({ now: true }),
-        lastUpdatedTimeLayergroup(),
-        layerStats(this.pgConnection, this.statsBackend),
-        layergroupIdHeader(this.templateMaps, useTemplateHash),
-        layergroupMetadata(this.layergroupMetadata, includeQuery),
-        mapError({ label, addContext })
-    ];
+        return [
+            credentials(),
+            authorize(this.authBackend),
+            dbConnSetup(this.pgConnection),
+            rateLimit(this.userLimitsBackend, RATE_LIMIT_ENDPOINTS_GROUPS.ANONYMOUS),
+            cleanUpQueryParams(['aggregation']),
+            initProfiler(isTemplateInstantiation),
+            checkJsonContentType(),
+            checkCreateLayergroup(),
+            prepareAdapterMapConfig(this.mapConfigAdapter),
+            createLayergroup (
+                this.mapBackend,
+                this.userLimitsBackend,
+                this.pgConnection,
+                this.layergroupAffectedTables
+            ),
+            incrementMapViewCount(this.metadataBackend),
+            augmentLayergroupData(),
+            cacheControlHeader({ ttl: global.environment.varnish.layergroupTtl || 86400, revalidate: true }),
+            cacheChannelHeader(),
+            surrogateKeyHeader({ surrogateKeysCache: this.surrogateKeysCache }),
+            lastModifiedHeader({ now: true }),
+            lastUpdatedTimeLayergroup(),
+            layerStats(this.pgConnection, this.statsBackend),
+            layergroupIdHeader(this.templateMaps, useTemplateHash),
+            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(
-            `/:token/:layer/attributes/:fid`,
+        mapRouter.get('/:token/:layer/attributes/:fid', this.middlewares());
+    }
+
+    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(
-            `/:token/dataview/:dataviewName`,
-            layergroupToken(),
-            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('/:token/dataview/:dataviewName', this.middlewares({
+            action: 'get',
+            rateLimitGroup: RATE_LIMIT_ENDPOINTS_GROUPS.DATAVIEW
+        }));
 
-        mapRouter.get(
-            `/:token/:layer/widget/:dataviewName`,
-            layergroupToken(),
-            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('/:token/:layer/widget/:dataviewName', this.middlewares({
+            action: 'get',
+            rateLimitGroup: RATE_LIMIT_ENDPOINTS_GROUPS.DATAVIEW
+        }));
 
-        mapRouter.get(
-            `/:token/dataview/:dataviewName/search`,
-            layergroupToken(),
-            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('/:token/dataview/:dataviewName/search', this.middlewares({
+            action: 'search',
+            rateLimitGroup: RATE_LIMIT_ENDPOINTS_GROUPS.DATAVIEW_SEARCH
+        }));
 
-        mapRouter.get(
-            `/:token/:layer/widget/:dataviewName/search`,
+        mapRouter.get('/:token/:layer/widget/:dataviewName/search', this.middlewares({
+            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/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');
@@ -32,34 +33,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(
-            `/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']),
-            createMapStoreMapConfigProvider(
-                this.mapStore,
-                this.userLimitsBackend,
-                this.pgConnection,
-                this.layergroupAffectedTablesCache,
-                forcedFormat
-            ),
-            getPreviewImageByCenter(this.previewBackend),
-            cacheControlHeader(),
-            cacheChannelHeader(),
-            surrogateKeyHeader({ surrogateKeysCache: this.surrogateKeysCache }),
-            lastModifiedHeader()
-        );
+        let getPreviewImage;
 
-        mapRouter.get(
-            `/static/bbox/:token/:west,:south,:east,:north/:width/:height.:format`,
+        if (previewType === 'centered') {
+            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),
@@ -72,12 +72,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

@@ -22,54 +22,57 @@ function numMapper(n) {
     return +n;
 }
 
-function PreviewTemplateController (
-    namedMapProviderCache,
-    previewBackend,
-    surrogateKeysCache,
-    tablesExtentBackend,
-    metadataBackend,
-    pgConnection,
-    authBackend,
-    userLimitsBackend
-) {
-    this.namedMapProviderCache = namedMapProviderCache;
-    this.previewBackend = previewBackend;
-    this.surrogateKeysCache = surrogateKeysCache;
-    this.tablesExtentBackend = tablesExtentBackend;
-    this.metadataBackend = metadataBackend;
-    this.pgConnection = pgConnection;
-    this.authBackend = authBackend;
-    this.userLimitsBackend = userLimitsBackend;
-}
+module.exports = class PreviewTemplateController {
+    constructor (
+        namedMapProviderCache,
+        previewBackend,
+        surrogateKeysCache,
+        tablesExtentBackend,
+        metadataBackend,
+        pgConnection,
+        authBackend,
+        userLimitsBackend
+    ) {
+        this.namedMapProviderCache = namedMapProviderCache;
+        this.previewBackend = previewBackend;
+        this.surrogateKeysCache = surrogateKeysCache;
+        this.tablesExtentBackend = tablesExtentBackend;
+        this.metadataBackend = metadataBackend;
+        this.pgConnection = pgConnection;
+        this.authBackend = authBackend;
+        this.userLimitsBackend = userLimitsBackend;
+    }
 
-module.exports = PreviewTemplateController;
+    register (mapRouter) {
+        mapRouter.get('/static/named/:template_id/:width/:height.:format', this.middlewares());
+    }
 
-PreviewTemplateController.prototype.register = function (mapRouter) {
-    mapRouter.get(
-        `/static/named/:template_id/:width/:height.:format`,
-        credentials(),
-        authorize(this.authBackend),
-        dbConnSetup(this.pgConnection),
-        rateLimit(this.userLimitsBackend, RATE_LIMIT_ENDPOINTS_GROUPS.STATIC_NAMED),
-        cleanUpQueryParams(['layer', 'zoom', 'lon', 'lat', 'bbox']),
-        namedMapProvider({
-            namedMapProviderCache: this.namedMapProviderCache,
-            label: 'STATIC_VIZ_MAP', forcedFormat: 'png'
-        }),
-        getTemplate({ label: 'STATIC_VIZ_MAP' }),
-        prepareLayerFilterFromPreviewLayers({
-            namedMapProviderCache: this.namedMapProviderCache,
-            label: 'STATIC_VIZ_MAP'
-        }),
-        getStaticImageOptions({ tablesExtentBackend: this.tablesExtentBackend }),
-        getImage({ previewBackend: this.previewBackend, label: 'STATIC_VIZ_MAP' }),
-        setContentTypeHeader(),
-        incrementMapViews({ metadataBackend: this.metadataBackend }),
-        cacheControlHeader(),
-        cacheChannelHeader(),
-        surrogateKeyHeader({ surrogateKeysCache: this.surrogateKeysCache }),
-        lastModifiedHeader()
-    );
+    middlewares () {
+        return [
+            credentials(),
+            authorize(this.authBackend),
+            dbConnSetup(this.pgConnection),
+            rateLimit(this.userLimitsBackend, RATE_LIMIT_ENDPOINTS_GROUPS.STATIC_NAMED),
+            cleanUpQueryParams(['layer', 'zoom', 'lon', 'lat', 'bbox']),
+            namedMapProvider({
+                namedMapProviderCache: this.namedMapProviderCache,
+                label: 'STATIC_VIZ_MAP', forcedFormat: 'png'
+            }),
+            getTemplate({ label: 'STATIC_VIZ_MAP' }),
+            prepareLayerFilterFromPreviewLayers({
+                namedMapProviderCache: this.namedMapProviderCache,
+                label: 'STATIC_VIZ_MAP'
+            }),
+            getStaticImageOptions({ tablesExtentBackend: this.tablesExtentBackend }),
+            getImage({ previewBackend: this.previewBackend, label: 'STATIC_VIZ_MAP' }),
+            setContentTypeHeader(),
+            incrementMapViews({ metadataBackend: this.metadataBackend }),
+            cacheControlHeader(),
+            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.:format`,
-                `/:token${not('static')}/:layer/:z/:x/:y.(:format)`
-            ],
+            `/:token/:z/:x/:y@:scale_factor?x.:format`, // 1
+            `/: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()
-        );
+        ];
     }
 };