Replace overviews by dynamic aggregation

[enekid]

Context: [PROJECT] Deprecate raster overviews

In order to keep current performance when dropping the overviews feature, it's desirable to activate dynamic aggregation also for raster tiles.

[enekid]

Context: Dynamic Aggregations [WIP]

Chain of Adapters

All the dynamic aggregation magic takes place in the Aggregation MapConfig Adapter that is initialized and added to de MapConfig adapters chain in the API router:

adapters = [
                new MapConfigNamedLayersAdapter(templateMaps, pgConnection),
                new MapConfigBufferSizeAdapter(),
                new SqlWrapMapConfigAdapter(),
                new DataviewsWidgetsAdapter(),
                new AnalysisMapConfigAdapter(analysisBackend),
                new VectorMapConfigAdapter(pgConnection),
                new AggregationMapConfigAdapter(pgConnection), // <<<====
                new TurboCartoAdapter()
            ];

Aggregation Adapter

This adapters getMapConfig function checks if the MapConfig should be adapted to use dynamic aggregation. If not, it returns the current adapted MapConfig without adding aggregation:

getMapConfig(user, requestMapConfig, params, context, callback) {
  //...
  if (!this._shouldAdapt(mapConfig, params)) {
      return callback(null, requestMapConfig);
  }
  //...
  this._adaptLayers(connection, mapConfig, requestMapConfig, context, callback);
}

The _shouldAdapt function checks if the param aggregation is true and if the mapConfig is aggregable

_shouldAdapt (mapConfig, params) {
    const { aggregation } = params;

    if (aggregation === 'false') {
        return false;
    }

    if (aggregation === 'true' || mapConfig.isAggregationMapConfig()) {
        return true;
    }

    return false;
}

The isAggregationMapConfig function is defined in the Aggregation Mapconfig model:

class AggregationMapConfig extends MapConfig {
  //...

  isAggregationMapConfig () {
      return this.isVectorOnlyMapConfig() || this.hasAnyLayerAggregation();
  }

  isAggregationLayer (index) {
      return this.isVectorOnlyMapConfig() || this.hasLayerAggregation(index);
  }

  //...
}

The function isVectorOnlyMapConfig is placed in Windshaft and checks that all the MapConfig layers are vector layers (isVectorLayer)

MapConfig.prototype.isVectorLayer = function (index) {
  const layer = this.getLayer(index);
  const type =  getType(layer.type);
  const sql = this.getLayerOption(index, 'sql');
  const cartocss = this.getLayerOption(index, 'cartocss');
  const cartocssVersion = this.getLayerOption(index, 'cartocss_version');

  return type === 'mapnik' && 
             typeof sql === 'string' && 
             cartocss === undefined && 
             cartocssVersion === undefined;
};

The function hasAnyLayerAggregation checks that some of the MapConfig layers are marked for aggregation (hasLayerAggregation)

hasLayerAggregation (index) {
    const layer = this.getLayer(index);
    const { aggregation } = layer.options;

    return aggregation !== undefined && 
               (typeof aggregation === 'object' || typeof aggregation === 'boolean');
}

[dgaubert]

PR: #1038