@carto/api-client 0.3.1 → 0.4.0-alpha.1

package/build/api-client.cjs

@@ -3,7 +3,6 @@ var bboxPolygon = require('@turf/bbox-polygon');
 var union = require('@turf/union');
 var invariant = require('@turf/invariant');
 var helpers = require('@turf/helpers');
-var carto = require('@deck.gl/carto');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -35,8 +34,6 @@ function setClient(c) {
   client = c;
 }
 
-/** Current version of @carto/api-client. */
-const API_CLIENT_VERSION = "0.3.1";
 /**
  * Defines a comparator used when matching a column's values against given filter values.
  *
@@ -61,6 +58,31 @@ exports.FilterType = void 0;
   FilterType["TIME"] = "time";
   FilterType["STRING_SEARCH"] = "stringSearch";
 })(exports.FilterType || (exports.FilterType = {}));
+/** @internalRemarks Source: @carto/constants */
+exports.ApiVersion = void 0;
+(function (ApiVersion) {
+  ApiVersion["V1"] = "v1";
+  ApiVersion["V2"] = "v2";
+  ApiVersion["V3"] = "v3";
+})(exports.ApiVersion || (exports.ApiVersion = {}));
+/******************************************************************************
+ * DEFAULTS
+ */
+/** @internalRemarks Source: @carto/constants, @deck.gl/carto */
+const DEFAULT_API_BASE_URL = 'https://gcp-us-east1.api.carto.com';
+/** @internalRemarks Source: @carto/constants, @deck.gl/carto */
+const DEFAULT_CLIENT = 'deck-gl-carto';
+/** @internalRemarks Source: @carto/constants, @deck.gl/carto */
+const DEFAULT_GEO_COLUMN = 'geom';
+/**
+ * Fastly default limit is 8192; leave some padding.
+ * @internalRemarks Source: @deck.gl/carto
+ */
+const DEFAULT_MAX_LENGTH_URL = 7000;
+/** @internalRemarks Source: @deck.gl/carto */
+const DEFAULT_TILE_SIZE = 512;
+/** @internalRemarks Source: @deck.gl/carto */
+const DEFAULT_TILE_RESOLUTION = 0.5;
 
 const FILTER_TYPES = new Set(Object.values(exports.FilterType));
 const isFilterType = type => FILTER_TYPES.has(type);
@@ -129,6 +151,10 @@ function isEmptyObject(object) {
   }
   return true;
 }
+/** @internal */
+const isObject = x => x !== null && typeof x === 'object';
+/** @internal */
+const isPureObject = x => isObject(x) && x.constructor === {}.constructor;
 
 /**
  * Adds a {@link Filter} to the filter set. Any previous filters with the same
@@ -345,43 +371,6 @@ function _isMultiPolygon(geometry) {
   return invariant.getType(geometry) === 'MultiPolygon';
 }
 
-/******************************************************************************
- * DEFAULTS
- */
-/**
- * @internalRemarks Source: @carto/constants
- * @internal
- */
-const DEFAULT_API_BASE_URL = 'https://gcp-us-east1.api.carto.com';
-/**
- * @internalRemarks Source: @carto/react-api
- * @internal
- */
-const DEFAULT_GEO_COLUMN = 'geom';
-/******************************************************************************
- * ENUMS
- */
-/**
- * @internal
- * @internalRemarks Source: @carto/constants
- */
-var MapType;
-(function (MapType) {
-  MapType["TABLE"] = "table";
-  MapType["QUERY"] = "query";
-  MapType["TILESET"] = "tileset";
-})(MapType || (MapType = {}));
-/**
- * @internal
- * @internalRemarks Source: @carto/constants
- */
-var ApiVersion;
-(function (ApiVersion) {
-  ApiVersion["V1"] = "v1";
-  ApiVersion["V2"] = "v2";
-  ApiVersion["V3"] = "v3";
-})(ApiVersion || (ApiVersion = {}));
-
 /**
  * Return more descriptive error from API
  * @internalRemarks Source: @carto/react-api
@@ -476,7 +465,7 @@ function dealWithApiError(_ref) {
 const AVAILABLE_MODELS = ['category', 'histogram', 'formula', 'timeseries', 'range', 'scatterplot', 'table'];
 const {
   V3
-} = ApiVersion;
+} = exports.ApiVersion;
 const REQUEST_GET_MAX_URL_LENGTH = 2048;
 /**
  * Execute a SQL model request.
@@ -504,7 +493,7 @@ function executeModel(props) {
   assert(apiBaseUrl, 'executeModel: missing apiBaseUrl');
   assert(accessToken, 'executeModel: missing accessToken');
   assert(apiVersion === V3, 'executeModel: SQL Model API requires CARTO 3+');
-  assert(type !== MapType.TILESET, 'executeModel: Tilesets not supported');
+  assert(type !== 'tileset', 'executeModel: Tilesets not supported');
   let url = `${apiBaseUrl}/v3/sql/${connectionName}/model/${model}`;
   const {
     filters,
@@ -908,7 +897,7 @@ class WidgetBaseSource {
   }
 }
 WidgetBaseSource.defaultProps = {
-  apiVersion: ApiVersion.V3,
+  apiVersion: exports.ApiVersion.V3,
   apiBaseUrl: DEFAULT_API_BASE_URL,
   clientId: getClient(),
   filters: {},
@@ -942,7 +931,7 @@ class WidgetQuerySource extends WidgetBaseSource {
   getModelSource(owner) {
     return {
       ...super._getModelSource(owner),
-      type: MapType.QUERY,
+      type: 'query',
       data: this.props.sqlQuery,
       queryParameters: this.props.queryParameters
     };
@@ -975,19 +964,638 @@ class WidgetTableSource extends WidgetBaseSource {
   getModelSource(owner) {
     return {
       ...super._getModelSource(owner),
-      type: MapType.TABLE,
+      type: 'table',
       data: this.props.tableName
     };
   }
 }
 
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+function joinPath() {
+  return [].slice.call(arguments).map(part => part.endsWith('/') ? part.slice(0, -1) : part).join('/');
+}
+function buildV3Path(apiBaseUrl, version, endpoint) {
+  return joinPath(apiBaseUrl, version, endpoint, ...[].slice.call(arguments, 3));
+}
+/** @internal Required by fetchMap(). */
+function buildPublicMapUrl(_ref) {
+  let {
+    apiBaseUrl,
+    cartoMapId
+  } = _ref;
+  return buildV3Path(apiBaseUrl, 'v3', 'maps', 'public', cartoMapId);
+}
+/** @internal Required by fetchMap(). */
+function buildStatsUrl(_ref2) {
+  let {
+    attribute,
+    apiBaseUrl,
+    connectionName,
+    source,
+    type
+  } = _ref2;
+  if (type === 'query') {
+    return buildV3Path(apiBaseUrl, 'v3', 'stats', connectionName, attribute);
+  }
+  // type === 'table'
+  return buildV3Path(apiBaseUrl, 'v3', 'stats', connectionName, source, attribute);
+}
+function buildSourceUrl(_ref3) {
+  let {
+    apiBaseUrl,
+    connectionName,
+    endpoint
+  } = _ref3;
+  return buildV3Path(apiBaseUrl, 'v3', 'maps', connectionName, endpoint);
+}
+function buildQueryUrl(_ref4) {
+  let {
+    apiBaseUrl,
+    connectionName
+  } = _ref4;
+  return buildV3Path(apiBaseUrl, 'v3', 'sql', connectionName, 'query');
+}
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/**
+ *
+ * Custom error for reported errors in CARTO Maps API.
+ * Provides useful debugging information in console and context for applications.
+ *
+ */
+class CartoAPIError extends Error {
+  constructor(error, errorContext, response, responseJson) {
+    let responseString = 'Failed to connect';
+    if (response) {
+      responseString = 'Server returned: ';
+      if (response.status === 400) {
+        responseString += 'Bad request';
+      } else if (response.status === 401 || response.status === 403) {
+        responseString += 'Unauthorized access';
+      } else if (response.status === 404) {
+        responseString += 'Not found';
+      } else {
+        responseString += 'Error';
+      }
+      responseString += ` (${response.status}):`;
+    }
+    responseString += ` ${error.message || error}`;
+    let message = `${errorContext.requestType} API request failed`;
+    message += `\n${responseString}`;
+    for (const key of Object.keys(errorContext)) {
+      if (key === 'requestType') continue;
+      message += `\n${formatErrorKey(key)}: ${errorContext[key]}`;
+    }
+    message += '\n';
+    super(message);
+    /** Source error from server */
+    this.error = void 0;
+    /** Context (API call & parameters) in which error occured */
+    this.errorContext = void 0;
+    /** Response from server */
+    this.response = void 0;
+    /** JSON Response from server */
+    this.responseJson = void 0;
+    this.name = 'CartoAPIError';
+    this.response = response;
+    this.responseJson = responseJson;
+    this.error = error;
+    this.errorContext = errorContext;
+  }
+}
+/**
+ * Converts camelCase to Camel Case
+ */
+function formatErrorKey(key) {
+  return key.replace(/([A-Z])/g, ' $1').replace(/^./, s => s.toUpperCase());
+}
+
+/******************************************************************************
+ * VERSIONS
+ */
+/** @internal */
+const V3_MINOR_VERSION = '3.4';
+/**
+ * @internalRemarks Source: @deck.gl/carto
+ * @internal
+ */
+const DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
+/**
+ * @internalRemarks Source: @deck.gl/carto
+ * @internal
+ */
+const DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
+
+// deck.gl
+const requestWithParameters = function (_ref) {
+  let {
+    baseUrl,
+    parameters = {},
+    headers: customHeaders = {},
+    errorContext,
+    maxLengthURL = DEFAULT_MAX_LENGTH_URL
+  } = _ref;
+  try {
+    // Parameters added to all requests issued with `requestWithParameters()`.
+    // These parameters override parameters already in the base URL, but not
+    // user-provided parameters.
+    parameters = {
+      v: V3_MINOR_VERSION,
+      clientId: DEFAULT_CLIENT,
+      ...(typeof deck !== 'undefined' && deck.VERSION && {
+        deckglVersion: deck.VERSION
+      }),
+      ...parameters
+    };
+    baseUrl = excludeURLParameters(baseUrl, Object.keys(parameters));
+    const key = createCacheKey(baseUrl, parameters, customHeaders);
+    if (REQUEST_CACHE.has(key)) {
+      return Promise.resolve(REQUEST_CACHE.get(key));
+    }
+    const url = createURLWithParameters(baseUrl, parameters);
+    const headers = {
+      ...DEFAULT_HEADERS,
+      ...customHeaders
+    };
+    /* global fetch */
+    const fetchPromise = url.length > maxLengthURL ? fetch(baseUrl, {
+      method: 'POST',
+      body: JSON.stringify(parameters),
+      headers
+    }) : fetch(url, {
+      headers
+    });
+    let response;
+    let responseJson;
+    const jsonPromise = fetchPromise.then(_response => {
+      response = _response;
+      return response.json();
+    }).then(json => {
+      responseJson = json;
+      if (!response || !response.ok) {
+        throw new Error(json.error);
+      }
+      return json;
+    }).catch(error => {
+      REQUEST_CACHE.delete(key);
+      throw new CartoAPIError(error, errorContext, response, responseJson);
+    });
+    REQUEST_CACHE.set(key, jsonPromise);
+    return Promise.resolve(jsonPromise);
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+const DEFAULT_HEADERS = {
+  Accept: 'application/json',
+  'Content-Type': 'application/json'
+};
+const REQUEST_CACHE = new Map();
+function createCacheKey(baseUrl, parameters, headers) {
+  const parameterEntries = Object.entries(parameters).sort((_ref2, _ref3) => {
+    let [a] = _ref2;
+    let [b] = _ref3;
+    return a > b ? 1 : -1;
+  });
+  const headerEntries = Object.entries(headers).sort((_ref4, _ref5) => {
+    let [a] = _ref4;
+    let [b] = _ref5;
+    return a > b ? 1 : -1;
+  });
+  return JSON.stringify({
+    baseUrl,
+    parameters: parameterEntries,
+    headers: headerEntries
+  });
+}
+/**
+ * Appends query string parameters to a URL. Existing URL parameters are kept,
+ * unless there is a conflict, in which case the new parameters override
+ * those already in the URL.
+ */
+function createURLWithParameters(baseUrlString, parameters) {
+  const baseUrl = new URL(baseUrlString);
+  for (const [key, value] of Object.entries(parameters)) {
+    if (isPureObject(value) || Array.isArray(value)) {
+      baseUrl.searchParams.set(key, JSON.stringify(value));
+    } else {
+      baseUrl.searchParams.set(key, value.toString());
+    }
+  }
+  return baseUrl.toString();
+}
+/**
+ * Deletes query string parameters from a URL.
+ */
+function excludeURLParameters(baseUrlString, parameters) {
+  const baseUrl = new URL(baseUrlString);
+  for (const param of parameters) {
+    if (baseUrl.searchParams.has(param)) {
+      baseUrl.searchParams.delete(param);
+    }
+  }
+  return baseUrl.toString();
+}
+
+// deck.gl
+const baseSource = function (endpoint, options, urlParameters) {
+  try {
+    const {
+      accessToken,
+      connectionName,
+      cache,
+      ...optionalOptions
+    } = options;
+    const mergedOptions = {
+      ...SOURCE_DEFAULTS,
+      accessToken,
+      connectionName,
+      endpoint
+    };
+    for (const key in optionalOptions) {
+      if (optionalOptions[key]) {
+        mergedOptions[key] = optionalOptions[key];
+      }
+    }
+    const baseUrl = buildSourceUrl(mergedOptions);
+    const {
+      clientId,
+      maxLengthURL,
+      format
+    } = mergedOptions;
+    const headers = {
+      Authorization: `Bearer ${options.accessToken}`,
+      ...options.headers
+    };
+    const parameters = {
+      client: clientId,
+      ...urlParameters
+    };
+    const errorContext = {
+      requestType: 'Map instantiation',
+      connection: options.connectionName,
+      type: endpoint,
+      source: JSON.stringify(parameters, undefined, 2)
+    };
+    return Promise.resolve(requestWithParameters({
+      baseUrl,
+      parameters,
+      headers,
+      errorContext,
+      maxLengthURL
+    })).then(function (mapInstantiation) {
+      let _exit;
+      function _temp2(_result) {
+        return _exit ? _result : Promise.resolve(requestWithParameters({
+          baseUrl: dataUrl,
+          headers,
+          errorContext,
+          maxLengthURL
+        }));
+      }
+      const dataUrl = mapInstantiation[format].url[0];
+      if (cache) {
+        cache.value = parseInt(new URL(dataUrl).searchParams.get('cache') || '', 10);
+      }
+      errorContext.requestType = 'Map data';
+      const _temp = function () {
+        if (format === 'tilejson') {
+          return Promise.resolve(requestWithParameters({
+            baseUrl: dataUrl,
+            headers,
+            errorContext,
+            maxLengthURL
+          })).then(function (json) {
+            if (accessToken) {
+              json.accessToken = accessToken;
+            }
+            _exit = 1;
+            return json;
+          });
+        }
+      }();
+      return _temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp);
+    });
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+const SOURCE_DEFAULTS = {
+  apiBaseUrl: DEFAULT_API_BASE_URL,
+  clientId: DEFAULT_CLIENT,
+  format: 'tilejson',
+  headers: {},
+  maxLengthURL: DEFAULT_MAX_LENGTH_URL
+};
+
+// deck.gl
+const boundaryQuerySource = function (options) {
+  try {
+    const {
+      columns,
+      filters,
+      tilesetTableName,
+      propertiesSqlQuery,
+      queryParameters
+    } = options;
+    const urlParameters = {
+      tilesetTableName,
+      propertiesSqlQuery
+    };
+    if (columns) {
+      urlParameters.columns = columns.join(',');
+    }
+    if (filters) {
+      urlParameters.filters = filters;
+    }
+    if (queryParameters) {
+      urlParameters.queryParameters = queryParameters;
+    }
+    return Promise.resolve(baseSource('boundary', options, urlParameters));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+
+// deck.gl
+const boundaryTableSource = function (options) {
+  try {
+    const {
+      filters,
+      tilesetTableName,
+      columns,
+      propertiesTableName
+    } = options;
+    const urlParameters = {
+      tilesetTableName,
+      propertiesTableName
+    };
+    if (columns) {
+      urlParameters.columns = columns.join(',');
+    }
+    if (filters) {
+      urlParameters.filters = filters;
+    }
+    return Promise.resolve(baseSource('boundary', options, urlParameters));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+
+// deck.gl
+const h3QuerySource$1 = function (options) {
+  try {
+    const {
+      aggregationExp,
+      aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3,
+      sqlQuery,
+      spatialDataColumn = 'h3',
+      queryParameters,
+      filters
+    } = options;
+    const urlParameters = {
+      aggregationExp,
+      spatialDataColumn,
+      spatialDataType: 'h3',
+      q: sqlQuery
+    };
+    if (aggregationResLevel) {
+      urlParameters.aggregationResLevel = String(aggregationResLevel);
+    }
+    if (queryParameters) {
+      urlParameters.queryParameters = queryParameters;
+    }
+    if (filters) {
+      urlParameters.filters = filters;
+    }
+    return Promise.resolve(baseSource('query', options, urlParameters));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+
+// deck.gl
+const h3TableSource$1 = function (options) {
+  try {
+    const {
+      aggregationExp,
+      aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3,
+      spatialDataColumn = 'h3',
+      tableName,
+      filters
+    } = options;
+    const urlParameters = {
+      aggregationExp,
+      name: tableName,
+      spatialDataColumn,
+      spatialDataType: 'h3'
+    };
+    if (aggregationResLevel) {
+      urlParameters.aggregationResLevel = String(aggregationResLevel);
+    }
+    if (filters) {
+      urlParameters.filters = filters;
+    }
+    return Promise.resolve(baseSource('table', options, urlParameters));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+
+// deck.gl
+const h3TilesetSource = function (options) {
+  try {
+    const {
+      tableName
+    } = options;
+    const urlParameters = {
+      name: tableName
+    };
+    return Promise.resolve(baseSource('tileset', options, urlParameters));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+
+// deck.gl
+const rasterSource = function (options) {
+  try {
+    const {
+      tableName,
+      filters
+    } = options;
+    const urlParameters = {
+      name: tableName
+    };
+    if (filters) {
+      urlParameters.filters = filters;
+    }
+    return Promise.resolve(baseSource('raster', options, urlParameters));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+
+// deck.gl
+const quadbinQuerySource$1 = function (options) {
+  try {
+    const {
+      aggregationExp,
+      aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
+      sqlQuery,
+      spatialDataColumn = 'quadbin',
+      queryParameters,
+      filters
+    } = options;
+    const urlParameters = {
+      aggregationExp,
+      q: sqlQuery,
+      spatialDataColumn,
+      spatialDataType: 'quadbin'
+    };
+    if (aggregationResLevel) {
+      urlParameters.aggregationResLevel = String(aggregationResLevel);
+    }
+    if (queryParameters) {
+      urlParameters.queryParameters = queryParameters;
+    }
+    if (filters) {
+      urlParameters.filters = filters;
+    }
+    return Promise.resolve(baseSource('query', options, urlParameters));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+
+// deck.gl
+const quadbinTableSource$1 = function (options) {
+  try {
+    const {
+      aggregationExp,
+      aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
+      spatialDataColumn = 'quadbin',
+      tableName,
+      filters
+    } = options;
+    const urlParameters = {
+      aggregationExp,
+      name: tableName,
+      spatialDataColumn,
+      spatialDataType: 'quadbin'
+    };
+    if (aggregationResLevel) {
+      urlParameters.aggregationResLevel = String(aggregationResLevel);
+    }
+    if (filters) {
+      urlParameters.filters = filters;
+    }
+    return Promise.resolve(baseSource('table', options, urlParameters));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+
+// deck.gl
+const quadbinTilesetSource = function (options) {
+  try {
+    const {
+      tableName
+    } = options;
+    const urlParameters = {
+      name: tableName
+    };
+    return Promise.resolve(baseSource('tileset', options, urlParameters));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+
+// deck.gl
+const vectorQuerySource$1 = function (options) {
+  try {
+    const {
+      columns,
+      filters,
+      spatialDataColumn = 'geom',
+      sqlQuery,
+      tileResolution = DEFAULT_TILE_RESOLUTION,
+      queryParameters
+    } = options;
+    const urlParameters = {
+      spatialDataColumn,
+      spatialDataType: 'geo',
+      tileResolution: tileResolution.toString(),
+      q: sqlQuery
+    };
+    if (columns) {
+      urlParameters.columns = columns.join(',');
+    }
+    if (filters) {
+      urlParameters.filters = filters;
+    }
+    if (queryParameters) {
+      urlParameters.queryParameters = queryParameters;
+    }
+    return Promise.resolve(baseSource('query', options, urlParameters));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+
+// deck.gl
+const vectorTableSource$1 = function (options) {
+  try {
+    const {
+      columns,
+      filters,
+      spatialDataColumn = 'geom',
+      tableName,
+      tileResolution = DEFAULT_TILE_RESOLUTION
+    } = options;
+    const urlParameters = {
+      name: tableName,
+      spatialDataColumn,
+      spatialDataType: 'geo',
+      tileResolution: tileResolution.toString()
+    };
+    if (columns) {
+      urlParameters.columns = columns.join(',');
+    }
+    if (filters) {
+      urlParameters.filters = filters;
+    }
+    return Promise.resolve(baseSource('table', options, urlParameters));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+
+// deck.gl
+const vectorTilesetSource = function (options) {
+  try {
+    const {
+      tableName
+    } = options;
+    const urlParameters = {
+      name: tableName
+    };
+    return Promise.resolve(baseSource('tileset', options, urlParameters));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+
 /** Wrapper adding Widget API support to [vectorTableSource](https://deck.gl/docs/api-reference/carto/data-sources). */
 
 /** Wrapper adding Widget API support to [quadbinQuerySource](https://deck.gl/docs/api-reference/carto/data-sources). */
 const quadbinQuerySource = function (props) {
   try {
-    assignDefaultProps(props);
-    return Promise.resolve(carto.quadbinQuerySource(props)).then(function (response) {
+    return Promise.resolve(quadbinQuerySource$1(props)).then(function (response) {
       return {
         ...response,
         widgetSource: new WidgetQuerySource(props)
@@ -1000,8 +1608,7 @@ const quadbinQuerySource = function (props) {
 /** Wrapper adding Widget API support to [quadbinTableSource](https://deck.gl/docs/api-reference/carto/data-sources). */
 const quadbinTableSource = function (props) {
   try {
-    assignDefaultProps(props);
-    return Promise.resolve(carto.quadbinTableSource(props)).then(function (response) {
+    return Promise.resolve(quadbinTableSource$1(props)).then(function (response) {
       return {
         ...response,
         widgetSource: new WidgetTableSource(props)
@@ -1014,8 +1621,7 @@ const quadbinTableSource = function (props) {
 /** Wrapper adding Widget API support to [h3QuerySource](https://deck.gl/docs/api-reference/carto/data-sources). */
 const h3QuerySource = function (props) {
   try {
-    assignDefaultProps(props);
-    return Promise.resolve(carto.h3QuerySource(props)).then(function (response) {
+    return Promise.resolve(h3QuerySource$1(props)).then(function (response) {
       return {
         ...response,
         widgetSource: new WidgetQuerySource(props)
@@ -1028,8 +1634,7 @@ const h3QuerySource = function (props) {
 /** Wrapper adding Widget API support to [h3TableSource](https://deck.gl/docs/api-reference/carto/data-sources). */
 const h3TableSource = function (props) {
   try {
-    assignDefaultProps(props);
-    return Promise.resolve(carto.h3TableSource(props)).then(function (response) {
+    return Promise.resolve(h3TableSource$1(props)).then(function (response) {
       return {
         ...response,
         widgetSource: new WidgetTableSource(props)
@@ -1042,8 +1647,7 @@ const h3TableSource = function (props) {
 /** Wrapper adding Widget API support to [vectorQuerySource](https://deck.gl/docs/api-reference/carto/data-sources). */
 const vectorQuerySource = function (props) {
   try {
-    assignDefaultProps(props);
-    return Promise.resolve(carto.vectorQuerySource(props)).then(function (response) {
+    return Promise.resolve(vectorQuerySource$1(props)).then(function (response) {
       return {
         ...response,
         widgetSource: new WidgetQuerySource(props)
@@ -1055,8 +1659,7 @@ const vectorQuerySource = function (props) {
 };
 const vectorTableSource = function (props) {
   try {
-    assignDefaultProps(props);
-    return Promise.resolve(carto.vectorTableSource(props)).then(function (response) {
+    return Promise.resolve(vectorTableSource$1(props)).then(function (response) {
       return {
         ...response,
         widgetSource: new WidgetTableSource(props)
@@ -1066,20 +1669,70 @@ const vectorTableSource = function (props) {
     return Promise.reject(e);
   }
 };
-function assignDefaultProps(props) {
-  if (typeof deck !== 'undefined' && deck && deck.VERSION) {
-    props.clientId ||= 'deck-gl-carto';
-    // TODO: Uncomment if/when `@deck.gl/carto` devDependency is removed,
-    // and source functions are moved here rather than wrapped.
-    // props.deckglVersion ||= deck.VERSION;
+
+// deck.gl
+const query = function (options) {
+  try {
+    const {
+      apiBaseUrl = SOURCE_DEFAULTS.apiBaseUrl,
+      clientId = SOURCE_DEFAULTS.clientId,
+      maxLengthURL = SOURCE_DEFAULTS.maxLengthURL,
+      connectionName,
+      sqlQuery,
+      queryParameters
+    } = options;
+    const urlParameters = {
+      q: sqlQuery
+    };
+    if (queryParameters) {
+      urlParameters.queryParameters = JSON.stringify(queryParameters);
+    }
+    const baseUrl = buildQueryUrl({
+      apiBaseUrl,
+      connectionName
+    });
+    const headers = {
+      Authorization: `Bearer ${options.accessToken}`,
+      ...options.headers
+    };
+    const parameters = {
+      client: clientId,
+      ...urlParameters
+    };
+    const errorContext = {
+      requestType: 'SQL',
+      connection: options.connectionName,
+      type: 'query',
+      source: JSON.stringify(parameters, undefined, 2)
+    };
+    return Promise.resolve(requestWithParameters({
+      baseUrl,
+      parameters,
+      headers,
+      errorContext,
+      maxLengthURL
+    }));
+  } catch (e) {
+    return Promise.reject(e);
   }
-}
+};
 
-exports.API_CLIENT_VERSION = API_CLIENT_VERSION;
+exports.CartoAPIError = CartoAPIError;
+exports.DEFAULT_API_BASE_URL = DEFAULT_API_BASE_URL;
+exports.DEFAULT_CLIENT = DEFAULT_CLIENT;
+exports.DEFAULT_GEO_COLUMN = DEFAULT_GEO_COLUMN;
+exports.DEFAULT_MAX_LENGTH_URL = DEFAULT_MAX_LENGTH_URL;
+exports.DEFAULT_TILE_RESOLUTION = DEFAULT_TILE_RESOLUTION;
+exports.DEFAULT_TILE_SIZE = DEFAULT_TILE_SIZE;
+exports.SOURCE_DEFAULTS = SOURCE_DEFAULTS;
 exports.WidgetBaseSource = WidgetBaseSource;
 exports.WidgetQuerySource = WidgetQuerySource;
 exports.WidgetTableSource = WidgetTableSource;
 exports.addFilter = addFilter;
+exports.boundaryQuerySource = boundaryQuerySource;
+exports.boundaryTableSource = boundaryTableSource;
+exports.buildPublicMapUrl = buildPublicMapUrl;
+exports.buildStatsUrl = buildStatsUrl;
 exports.clearFilters = clearFilters;
 exports.createPolygonSpatialFilter = createPolygonSpatialFilter;
 exports.createViewportSpatialFilter = createViewportSpatialFilter;
@@ -1087,11 +1740,17 @@ exports.getClient = getClient;
 exports.getFilter = getFilter;
 exports.h3QuerySource = h3QuerySource;
 exports.h3TableSource = h3TableSource;
+exports.h3TilesetSource = h3TilesetSource;
 exports.hasFilter = hasFilter;
 exports.quadbinQuerySource = quadbinQuerySource;
 exports.quadbinTableSource = quadbinTableSource;
+exports.quadbinTilesetSource = quadbinTilesetSource;
+exports.query = query;
+exports.rasterSource = rasterSource;
 exports.removeFilter = removeFilter;
+exports.requestWithParameters = requestWithParameters;
 exports.setClient = setClient;
 exports.vectorQuerySource = vectorQuerySource;
 exports.vectorTableSource = vectorTableSource;
+exports.vectorTilesetSource = vectorTilesetSource;
 //# sourceMappingURL=api-client.cjs.map