@deck.gl/carto 8.10.0-alpha.7 → 9.0.0-alpha.3

package/package.json

@@ -2,7 +2,7 @@
   "name": "@deck.gl/carto",
   "description": "CARTO official integration with Deck.gl. Build geospatial applications using CARTO and Deck.gl.",
   "license": "MIT",
-  "version": "8.10.0-alpha.7",
+  "version": "9.0.0-alpha.3",
   "publishConfig": {
     "access": "public"
   },
@@ -35,11 +35,12 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.0.0",
-    "@loaders.gl/gis": "^4.0.1",
-    "@loaders.gl/loader-utils": "^4.0.1",
-    "@loaders.gl/mvt": "^4.0.1",
-    "@loaders.gl/tiles": "^4.0.1",
-    "@luma.gl/constants": "^8.5.20",
+    "@loaders.gl/gis": "4.0.3",
+    "@loaders.gl/loader-utils": "4.0.3",
+    "@loaders.gl/mvt": "4.0.3",
+    "@loaders.gl/tiles": "4.0.3",
+    "@luma.gl/constants": "9.0.0-alpha.42",
+    "@luma.gl/core": "9.0.0-alpha.42",
     "@math.gl/web-mercator": "^4.0.0",
     "cartocolor": "^4.0.2",
     "d3-array": "^3.2.0",
@@ -52,7 +53,7 @@
     "quadbin": "^0.1.9"
   },
   "devDependencies": {
-    "@loaders.gl/schema": "^4.0.1",
+    "@loaders.gl/schema": "4.0.3",
     "@types/d3-array": "^3.0.2",
     "@types/d3-color": "^1.4.2",
     "@types/d3-scale": "^3.0.0"
@@ -63,7 +64,7 @@
     "@deck.gl/extensions": "^8.0.0",
     "@deck.gl/geo-layers": "^8.0.0",
     "@deck.gl/layers": "^8.0.0",
-    "@loaders.gl/core": "^4.0.1"
+    "@loaders.gl/core": "4.0.3"
   },
-  "gitHead": "1c62a9eec914019afd3969bc0c59f1488e491207"
+  "gitHead": "51dfb88f9168ccf478d01b28a2c5ada7bd8281c7"
 }

package/src/api/carto-api-error.ts

@@ -1,12 +1,4 @@
-import {MapType, RequestType} from './maps-api-common';
-
-export type APIErrorContext = {
-  requestType: RequestType;
-  mapId?: string;
-  connection?: string;
-  source?: string;
-  type?: MapType;
-};
+import type {APIErrorContext} from './types';
 
 /**
  *

package/src/api/common.ts

@@ -0,0 +1,14 @@
+export const DEFAULT_API_BASE_URL = 'https://gcp-us-east1.api.carto.com';
+export const DEFAULT_CLIENT = 'deck-gl-carto';
+export const V3_MINOR_VERSION = '3.3';
+export const MAX_GET_LENGTH = 8192;
+
+export const DEFAULT_PARAMETERS = {
+  client: DEFAULT_CLIENT,
+  v: V3_MINOR_VERSION
+};
+
+export const DEFAULT_HEADERS = {
+  Accept: 'application/json',
+  'Content-Type': 'application/json'
+};

package/src/api/endpoints.ts

@@ -0,0 +1,38 @@
+import {MapType} from './types';
+
+export type V3Endpoint = 'maps' | 'stats' | 'sql';
+
+function buildUrlFromBase(apiBaseUrl: string, endpoint: V3Endpoint) {
+  let suffix = `/v3/${endpoint}`;
+  if (apiBaseUrl.endsWith('/')) {
+    suffix = suffix.substring(1);
+  }
+
+  return `${apiBaseUrl}${suffix}`;
+}
+
+export function buildMapsUrlFromBase(apiBaseUrl: string): string {
+  return buildUrlFromBase(apiBaseUrl, 'maps');
+}
+
+export function buildStatsUrlFromBase(apiBaseUrl: string): string {
+  return buildUrlFromBase(apiBaseUrl, 'stats');
+}
+
+export function buildQueryUrlFromBase(apiBaseUrl: string): string {
+  return buildUrlFromBase(apiBaseUrl, 'sql');
+}
+
+export function buildSourceUrl({
+  apiBaseUrl,
+  connectionName,
+  endpoint,
+  mapsUrl
+}: {
+  apiBaseUrl: string;
+  connectionName: string;
+  endpoint: MapType;
+  mapsUrl?: string;
+}): string {
+  return `${mapsUrl || buildMapsUrlFromBase(apiBaseUrl)}/${connectionName}/${endpoint}`;
+}

package/src/api/fetch-map.ts

@@ -0,0 +1,287 @@
+/* eslint-disable camelcase */
+/**
+ * Maps API Client for Carto 3
+ */
+import {CartoAPIError} from './carto-api-error';
+import {DEFAULT_API_BASE_URL, DEFAULT_CLIENT} from './common';
+import {buildMapsUrlFromBase, buildStatsUrlFromBase} from './endpoints';
+import {
+  GeojsonResult,
+  JsonResult,
+  TilejsonResult,
+  h3QuerySource,
+  h3TableSource,
+  quadbinQuerySource,
+  quadbinTableSource,
+  vectorQuerySource,
+  vectorTableSource,
+  vectorTilesetSource
+} from '../sources';
+import {parseMap} from './parse-map';
+import {requestWithParameters} from './request-with-parameters';
+import {assert} from '../utils';
+import type {APIErrorContext, Format, MapType, QueryParameters} from './types';
+
+type Dataset = {
+  id: string;
+  type: MapType;
+  source: string;
+  cache?: number;
+  connectionName: string;
+  geoColumn: string;
+  data: TilejsonResult | GeojsonResult | JsonResult;
+  columns: string[];
+  format: Format;
+  aggregationExp: string;
+  aggregationResLevel: number;
+  queryParameters: QueryParameters;
+};
+
+/* global clearInterval, setInterval, URL */
+/* eslint-disable complexity, max-statements */
+async function _fetchMapDataset(
+  dataset: Dataset,
+  accessToken: string,
+  apiBaseUrl: string,
+  clientId?: string,
+  headers?: Record<string, string>
+) {
+  const {
+    aggregationExp,
+    aggregationResLevel,
+    connectionName,
+    columns,
+    format,
+    geoColumn,
+    source,
+    type,
+    queryParameters
+  } = dataset;
+
+  const cache: {value?: number} = {};
+  const globalOptions: any = {
+    accessToken,
+    apiBaseUrl,
+    cache,
+    clientId,
+    connectionName,
+    format,
+    headers
+  };
+
+  if (type === 'tileset') {
+    // TODO do we want a generic tilesetSource?
+    // @ts-ignore
+    dataset.data = await vectorTilesetSource({...globalOptions, tableName: source});
+  } else {
+    const [spatialDataType, spatialDataColumn] = geoColumn ? geoColumn.split(':') : ['geom'];
+    if (spatialDataType === 'geom') {
+      const options = {...globalOptions, spatialDataColumn};
+      if (type === 'table') {
+        dataset.data = await vectorTableSource({...options, columns, tableName: source});
+      } else if (type === 'query') {
+        dataset.data = await vectorQuerySource({...options, sqlQuery: source, queryParameters});
+      }
+    } else if (spatialDataType === 'h3') {
+      const options = {...globalOptions, aggregationExp, aggregationResLevel, spatialDataColumn};
+      if (type === 'table') {
+        dataset.data = await h3TableSource({...options, columns, tableName: source});
+      } else if (type === 'query') {
+        dataset.data = await h3QuerySource({...options, sqlQuery: source, queryParameters});
+      }
+    } else if (spatialDataType === 'quadbin') {
+      const options = {...globalOptions, aggregationExp, aggregationResLevel, spatialDataColumn};
+      if (type === 'table') {
+        dataset.data = await quadbinTableSource({...options, columns, tableName: source});
+      } else if (type === 'query') {
+        dataset.data = await quadbinQuerySource({...options, sqlQuery: source, queryParameters});
+      }
+    }
+  }
+  let cacheChanged = true;
+  if (cache.value) {
+    cacheChanged = dataset.cache !== cache.value;
+    dataset.cache = cache.value;
+  }
+
+  return cacheChanged;
+}
+
+async function _fetchTilestats(
+  attribute,
+  dataset: Dataset,
+  accessToken: string,
+  apiBaseUrl: string
+) {
+  const {connectionName: connection, data, id, source, type} = dataset;
+  const errorContext: APIErrorContext = {requestType: 'Tile stats', connection, type, source};
+  if (!('tilestats' in data)) {
+    throw new CartoAPIError(new Error(`Invalid dataset for tilestats: ${id}`), errorContext);
+  }
+
+  const statsUrl = buildStatsUrlFromBase(apiBaseUrl);
+  let baseUrl = `${statsUrl}/${connection}/`;
+  if (type === 'query') {
+    baseUrl += attribute;
+  } else {
+    // MAP_TYPE.TABLE
+    baseUrl += `${source}/${attribute}`;
+  }
+
+  const headers = {Authorization: `Bearer ${accessToken}`};
+  const stats = await requestWithParameters({
+    baseUrl,
+    headers,
+    parameters: type === 'query' ? {q: source} : {},
+    errorContext
+  });
+
+  // Replace tilestats for attribute with value from API
+  const {attributes} = data.tilestats.layers[0];
+  const index = attributes.findIndex(d => d.attribute === attribute);
+  attributes[index] = stats;
+  return true;
+}
+
+async function fillInMapDatasets(
+  {datasets, token}: {datasets: Dataset[]; token: string},
+  clientId: string,
+  apiBaseUrl: string,
+  headers?: Record<string, string>
+) {
+  const promises = datasets.map(dataset =>
+    _fetchMapDataset(dataset, token, apiBaseUrl, clientId, headers)
+  );
+  return await Promise.all(promises);
+}
+
+async function fillInTileStats(
+  {datasets, keplerMapConfig, token}: {datasets: Dataset[]; keplerMapConfig: any; token: string},
+  apiBaseUrl: string
+) {
+  const attributes: {attribute?: string; dataset?: any}[] = [];
+  const {layers} = keplerMapConfig.config.visState;
+  for (const layer of layers) {
+    for (const channel of Object.keys(layer.visualChannels)) {
+      const attribute = layer.visualChannels[channel]?.name;
+      if (attribute) {
+        const dataset = datasets.find(d => d.id === layer.config.dataId);
+        if (dataset && dataset.type !== 'tileset' && (dataset.data as TilejsonResult).tilestats) {
+          // Only fetch stats for QUERY & TABLE map types
+          attributes.push({attribute, dataset});
+        }
+      }
+    }
+  }
+  // Remove duplicates to avoid repeated requests
+  const filteredAttributes: {attribute?: string; dataset?: any}[] = [];
+  for (const a of attributes) {
+    if (
+      !filteredAttributes.find(
+        ({attribute, dataset}) => attribute === a.attribute && dataset === a.dataset
+      )
+    ) {
+      filteredAttributes.push(a);
+    }
+  }
+
+  const promises = filteredAttributes.map(({attribute, dataset}) =>
+    _fetchTilestats(attribute, dataset, token, apiBaseUrl)
+  );
+  return await Promise.all(promises);
+}
+
+export type FetchMapOptions = {
+  apiBaseUrl?: string;
+  cartoMapId: string;
+  clientId?: string;
+  headers?: Record<string, string>;
+  mapsUrl?: string;
+  autoRefresh?: number;
+  onNewData?: (map: any) => void;
+};
+
+/* eslint-disable max-statements */
+export async function fetchMap({
+  apiBaseUrl = DEFAULT_API_BASE_URL,
+  cartoMapId,
+  clientId = DEFAULT_CLIENT,
+  headers = {},
+  mapsUrl,
+  autoRefresh,
+  onNewData
+}: FetchMapOptions) {
+  assert(cartoMapId, 'Must define CARTO map id: fetchMap({cartoMapId: "XXXX-XXXX-XXXX"})');
+  assert(apiBaseUrl, 'Must define apiBaseUrl');
+
+  if (autoRefresh || onNewData) {
+    assert(onNewData, 'Must define `onNewData` when using autoRefresh');
+    assert(typeof onNewData === 'function', '`onNewData` must be a function');
+    assert(
+      typeof autoRefresh === 'number' && autoRefresh > 0,
+      '`autoRefresh` must be a positive number'
+    );
+  }
+
+  const baseUrl = `${mapsUrl || buildMapsUrlFromBase(apiBaseUrl)}/public/${cartoMapId}`;
+  const errorContext: APIErrorContext = {requestType: 'Public map', mapId: cartoMapId};
+  const map = await requestWithParameters({baseUrl, headers, errorContext});
+
+  // Periodically check if the data has changed. Note that this
+  // will not update when a map is published.
+  let stopAutoRefresh: (() => void) | undefined;
+  if (autoRefresh) {
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    const intervalId = setInterval(async () => {
+      const changed = await fillInMapDatasets(map, clientId, apiBaseUrl, {
+        ...headers,
+        'If-Modified-Since': new Date().toUTCString()
+      });
+      if (onNewData && changed.some(v => v === true)) {
+        onNewData(parseMap(map));
+      }
+    }, autoRefresh * 1000);
+    stopAutoRefresh = () => {
+      clearInterval(intervalId);
+    };
+  }
+
+  const geojsonLayers = map.keplerMapConfig.config.visState.layers.filter(
+    ({type}) => type === 'geojson' || type === 'point'
+  );
+  const geojsonDatasetIds = geojsonLayers.map(({config}) => config.dataId);
+  map.datasets.forEach(dataset => {
+    if (geojsonDatasetIds.includes(dataset.id)) {
+      const {config} = geojsonLayers.find(({config}) => config.dataId === dataset.id);
+      dataset.format = 'geojson';
+      // Support for very old maps. geoColumn was not stored in the past
+      if (!dataset.geoColumn && config.columns.geojson) {
+        dataset.geoColumn = config.columns.geojson;
+      }
+    }
+  });
+
+  // Mutates map.datasets so that dataset.data contains data
+  await fillInMapDatasets(map, clientId, apiBaseUrl, headers);
+
+  // Mutates attributes in visualChannels to contain tile stats
+  await fillInTileStats(map, apiBaseUrl);
+  const out = {...parseMap(map), ...{stopAutoRefresh}};
+
+  const textLayers = out.layers.filter(layer => {
+    const pointType = layer.props.pointType || '';
+    return pointType.includes('text');
+  });
+
+  /* global FontFace, window, document */
+  if (textLayers.length && window.FontFace && !document.fonts.check('12px Inter')) {
+    // Fetch font needed for labels
+    const font = new FontFace(
+      'Inter',
+      'url(https://fonts.gstatic.com/s/inter/v12/UcC73FwrK3iLTeHuS_fvQtMwCp50KnMa1ZL7W0Q5nw.woff2)'
+    );
+    await font.load().then(f => document.fonts.add(f));
+  }
+
+  return out;
+}

package/src/api/index.ts

@@ -1,6 +1,6 @@
 export {CartoAPIError} from './carto-api-error';
-export type {APIErrorContext} from './carto-api-error';
-export {FORMATS, TILE_FORMATS, MAP_TYPES, API_VERSIONS} from './maps-api-common';
-export type {QueryParameters} from './maps-api-common';
-export {getDataV2, CONNECTIONS} from './maps-client';
-export {fetchLayerData, fetchMap, mapInstantiation} from './maps-v3-client';
+export {fetchMap} from './fetch-map';
+export type {FetchMapOptions} from './fetch-map';
+export type {APIErrorContext, Format, MapType, RequestType, QueryParameters} from './types';
+export {query} from './query';
+export type {QueryOptions} from './query';

package/src/api/layer-map.ts

@@ -22,8 +22,8 @@ import H3TileLayer from '../layers/h3-tile-layer';
 import QuadbinTileLayer from '../layers/quadbin-tile-layer';
 import RasterTileLayer from '../layers/raster-tile-layer';
 import VectorTileLayer from '../layers/vector-tile-layer';
-import {MapType, TILE_FORMATS, TileFormat} from './maps-api-common';
-import {assert, createBinaryProxy} from '../utils';
+import {MapType} from './types';
+import {assert, createBinaryProxy, scaleIdentity} from '../utils';
 import {
   CustomMarkersRange,
   MapDataset,
@@ -41,7 +41,8 @@ const SCALE_FUNCS = {
   quantile: scaleQuantile,
   quantize: scaleQuantize,
   sqrt: scaleSqrt,
-  custom: scaleThreshold
+  custom: scaleThreshold,
+  identity: scaleIdentity
 };
 export type SCALE_TYPE = keyof typeof SCALE_FUNCS;
 
@@ -201,7 +202,6 @@ export function getLayer(
 }
 
 export function layerFromTileDataset(
-  formatTiles: TileFormat | null = TILE_FORMATS.MVT,
   scheme: string,
   type?: MapType
 ): typeof VectorTileLayer | typeof H3TileLayer | typeof QuadbinTileLayer {
@@ -222,22 +222,16 @@ function getTileLayer(dataset: MapDataset, basePropMap) {
   const {
     aggregationExp,
     aggregationResLevel,
-    data: {
-      scheme,
-      tiles: [tileUrl]
-    }
+    data: {scheme}
   } = dataset;
-  /* global URL */
-  const formatTiles = new URL(tileUrl).searchParams.get('formatTiles') as TileFormat;
 
   return {
-    Layer: layerFromTileDataset(formatTiles, scheme),
+    Layer: layerFromTileDataset(scheme),
     propMap: basePropMap,
     defaultProps: {
       ...defaultProps,
       ...(aggregationExp && {aggregationExp}),
       ...(aggregationResLevel && {aggregationResLevel}),
-      formatTiles,
       uniqueIdProperty: 'geoid'
     }
   };
@@ -313,7 +307,7 @@ export function opacityToAlpha(opacity?: number) {
   return opacity !== undefined ? Math.round(255 * Math.pow(opacity, 1 / 2.2)) : 255;
 }
 
-function getAccessorKeys(name: string, aggregation: string | undefined): string[] {
+function getAccessorKeys(name: string, aggregation?: string | undefined): string[] {
   let keys = [name];
   if (aggregation) {
     // Snowflake will capitalized the keys, need to check lower and upper case version
@@ -339,33 +333,13 @@ export function getColorValueAccessor({name}, colorAggregation, data: any) {
 }
 
 export function getColorAccessor(
-  {name},
+  {name, colorColumn}: VisualChannelField,
   scaleType: SCALE_TYPE,
-  {aggregation, range: {colors, colorMap}},
+  {aggregation, range},
   opacity: number | undefined,
   data: any
 ) {
-  const scale = SCALE_FUNCS[scaleType as any]();
-  let domain: (string | number)[] = [];
-  let scaleColor: string[] = [];
-
-  if (Array.isArray(colorMap)) {
-    colorMap.forEach(([value, color]) => {
-      domain.push(value);
-      scaleColor.push(color);
-    });
-  } else {
-    domain = calculateDomain(data, name, scaleType, colors.length);
-    scaleColor = colors;
-  }
-
-  if (scaleType === 'ordinal') {
-    domain = domain.slice(0, scaleColor.length);
-  }
-
-  scale.domain(domain);
-  scale.range(scaleColor);
-  scale.unknown(UNKNOWN_COLOR);
+  const scale = calculateLayerScale(colorColumn || name, scaleType, range, data);
   const alpha = opacityToAlpha(opacity);
 
   let accessorKeys = getAccessorKeys(name, aggregation);
@@ -380,6 +354,36 @@ export function getColorAccessor(
   return normalizeAccessor(accessor, data);
 }
 
+function calculateLayerScale(name, scaleType, range, data) {
+  const scale = SCALE_FUNCS[scaleType]();
+  let domain: (string | number)[] = [];
+  let scaleColor: string[] = [];
+
+  if (scaleType !== 'identity') {
+    const {colorMap, colors} = range;
+
+    if (Array.isArray(colorMap)) {
+      colorMap.forEach(([value, color]) => {
+        domain.push(value);
+        scaleColor.push(color);
+      });
+    } else {
+      domain = calculateDomain(data, name, scaleType, colors.length);
+      scaleColor = colors;
+    }
+
+    if (scaleType === 'ordinal') {
+      domain = domain.slice(0, scaleColor.length);
+    }
+  }
+
+  scale.domain(domain);
+  scale.range(scaleColor);
+  scale.unknown(UNKNOWN_COLOR);
+
+  return scale;
+}
+
 const FALLBACK_ICON =
   'data:image/svg+xml;charset=utf-8;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTAwIDEwMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4NCiAgPGNpcmNsZSBjeD0iNTAiIGN5PSI1MCIgcj0iNTAiLz4NCjwvc3ZnPg==';
 

package/src/api/{parseMap.ts → parse-map.ts}

@@ -1,4 +1,5 @@
-import GL from '@luma.gl/constants';
+import {GL} from '@luma.gl/constants';
+import {log} from '@deck.gl/core';
 import {
   AGGREGATION,
   getLayer,
@@ -13,7 +14,6 @@ import {
   getMaxMarkerSize
 } from './layer-map';
 import PointLabelLayer from '../layers/point-label-layer';
-import {log} from '@deck.gl/core';
 import {CollisionFilterExtension} from '@deck.gl/extensions';
 import {assert} from '../utils';
 import {MapDataset, MapLayerConfig, VisualChannels} from './types';

package/src/api/query.ts

@@ -0,0 +1,34 @@
+import {SOURCE_DEFAULTS} from '../sources';
+import type {SourceOptions, QuerySourceOptions, QueryResult} from '../sources/types';
+import {buildQueryUrlFromBase} from './endpoints';
+import {requestWithParameters} from './request-with-parameters';
+import {APIErrorContext} from './types';
+
+export type QueryOptions = SourceOptions & Omit<QuerySourceOptions, 'spatialDataColumn'>;
+type UrlParameters = {q: string; queryParameters?: string};
+
+export const query = async function (options: QueryOptions): Promise<QueryResult> {
+  const {apiBaseUrl, connectionName, sqlQuery, queryParameters} = options;
+  const urlParameters: UrlParameters = {q: sqlQuery};
+
+  if (queryParameters) {
+    urlParameters.queryParameters = JSON.stringify(queryParameters);
+  }
+
+  const queryUrl = buildQueryUrlFromBase(apiBaseUrl || SOURCE_DEFAULTS.apiBaseUrl);
+  const baseUrl = `${queryUrl}/${connectionName}/query`;
+  const headers = {Authorization: `Bearer ${options.accessToken}`, ...options.headers};
+
+  const errorContext: APIErrorContext = {
+    requestType: 'SQL',
+    connection: options.connectionName,
+    type: 'query',
+    source: JSON.stringify(urlParameters, undefined, 2)
+  };
+  return await requestWithParameters<QueryResult>({
+    baseUrl,
+    parameters: urlParameters,
+    headers,
+    errorContext
+  });
+};

package/src/{sources/utils.ts → api/request-with-parameters.ts}

@@ -1,19 +1,33 @@
-import {APIErrorContext, CartoAPIError} from '../api/carto-api-error';
-import {encodeParameter, MapType} from '../api/maps-api-common';
+import {CartoAPIError} from './carto-api-error';
 import {DEFAULT_HEADERS, DEFAULT_PARAMETERS, MAX_GET_LENGTH} from './common';
-import {buildMapsUrlFromBase} from '../config';
+import type {APIErrorContext} from './types';
 
+/**
+ * Simple encode parameter
+ */
+function encodeParameter(name: string, value: string | boolean | number): string {
+  return `${name}=${encodeURIComponent(value)}`;
+}
+
+const REQUEST_CACHE = new Map();
 export async function requestWithParameters<T = any>({
+  accessToken,
   baseUrl,
   parameters,
   headers: customHeaders,
   errorContext
 }: {
+  accessToken?: string;
   baseUrl: string;
   parameters?: Record<string, string>;
   headers: Record<string, string>;
   errorContext: APIErrorContext;
 }): Promise<T> {
+  const key = JSON.stringify({baseUrl, parameters, customHeaders});
+  if (REQUEST_CACHE.has(key)) {
+    return REQUEST_CACHE.get(key);
+  }
+
   let url = baseUrl;
   if (parameters) {
     const allParameters = {...DEFAULT_PARAMETERS, ...parameters};
@@ -35,29 +49,20 @@ export async function requestWithParameters<T = any>({
     let json: any;
     try {
       json = await response.json();
+      if (accessToken) {
+        json.accessToken = accessToken;
+      }
     } catch {
       json = {error: ''};
     }
     if (!response.ok) {
+      REQUEST_CACHE.delete(key);
       throw new CartoAPIError(json.error, errorContext, response);
     }
 
+    REQUEST_CACHE.set(key, json);
     return json;
   } catch (error) {
     throw new CartoAPIError(error as Error, errorContext);
   }
 }
-
-export function buildApiEndpoint({
-  apiBaseUrl,
-  connectionName,
-  endpoint,
-  mapsUrl
-}: {
-  apiBaseUrl: string;
-  connectionName: string;
-  endpoint: MapType;
-  mapsUrl?: string;
-}): string {
-  return `${mapsUrl || buildMapsUrlFromBase(apiBaseUrl)}/${connectionName}/${endpoint}`;
-}