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

package/build/api-client.modern.js

@@ -3,7 +3,6 @@ import bboxPolygon from '@turf/bbox-polygon';
 import union from '@turf/union';
 import { getType } from '@turf/invariant';
 import { featureCollection, feature, polygon, multiPolygon } from '@turf/helpers';
-import { vectorTableSource as vectorTableSource$1, vectorQuerySource as vectorQuerySource$1, h3TableSource as h3TableSource$1, h3QuerySource as h3QuerySource$1, quadbinTableSource as quadbinTableSource$1, quadbinQuerySource as quadbinQuerySource$1 } from '@deck.gl/carto';
 
 /**
  * @internal
@@ -29,8 +28,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.
  *
@@ -55,6 +52,31 @@ var FilterType;
   FilterType["TIME"] = "time";
   FilterType["STRING_SEARCH"] = "stringSearch";
 })(FilterType || (FilterType = {}));
+/** @internalRemarks Source: @carto/constants */
+var ApiVersion;
+(function (ApiVersion) {
+  ApiVersion["V1"] = "v1";
+  ApiVersion["V2"] = "v2";
+  ApiVersion["V3"] = "v3";
+})(ApiVersion || (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(FilterType));
 const isFilterType = type => FILTER_TYPES.has(type);
@@ -123,6 +145,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
@@ -357,43 +383,6 @@ function _objectWithoutPropertiesLoose(r, e) {
   return t;
 }
 
-/******************************************************************************
- * 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
@@ -488,7 +477,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,
@@ -536,7 +525,7 @@ function executeModel(props) {
   });
 }
 
-const _excluded = ["filterOwner", "spatialFilter", "abortController"],
+const _excluded$1 = ["filterOwner", "spatialFilter", "abortController"],
   _excluded2 = ["filterOwner", "spatialFilter", "abortController", "operationExp"],
   _excluded3 = ["filterOwner", "spatialFilter", "abortController"],
   _excluded4 = ["filterOwner", "spatialFilter", "abortController"],
@@ -579,7 +568,7 @@ class WidgetBaseSource {
         spatialFilter,
         abortController
       } = options,
-      params = _objectWithoutPropertiesLoose(options, _excluded);
+      params = _objectWithoutPropertiesLoose(options, _excluded$1);
     const {
       column,
       operation,
@@ -884,7 +873,7 @@ WidgetBaseSource.defaultProps = {
 class WidgetQuerySource extends WidgetBaseSource {
   getModelSource(owner) {
     return _extends({}, super._getModelSource(owner), {
-      type: MapType.QUERY,
+      type: 'query',
       data: this.props.sqlQuery,
       queryParameters: this.props.queryParameters
     });
@@ -916,15 +905,547 @@ class WidgetQuerySource extends WidgetBaseSource {
 class WidgetTableSource extends WidgetBaseSource {
   getModelSource(owner) {
     return _extends({}, 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(...args) {
+  return args.map(part => part.endsWith('/') ? part.slice(0, -1) : part).join('/');
+}
+function buildV3Path(apiBaseUrl, version, endpoint, ...rest) {
+  return joinPath(apiBaseUrl, version, endpoint, ...rest);
+}
+/** @internal Required by fetchMap(). */
+function buildPublicMapUrl({
+  apiBaseUrl,
+  cartoMapId
+}) {
+  return buildV3Path(apiBaseUrl, 'v3', 'maps', 'public', cartoMapId);
+}
+/** @internal Required by fetchMap(). */
+function buildStatsUrl({
+  attribute,
+  apiBaseUrl,
+  connectionName,
+  source,
+  type
+}) {
+  if (type === 'query') {
+    return buildV3Path(apiBaseUrl, 'v3', 'stats', connectionName, attribute);
+  }
+  // type === 'table'
+  return buildV3Path(apiBaseUrl, 'v3', 'stats', connectionName, source, attribute);
+}
+function buildSourceUrl({
+  apiBaseUrl,
+  connectionName,
+  endpoint
+}) {
+  return buildV3Path(apiBaseUrl, 'v3', 'maps', connectionName, endpoint);
+}
+function buildQueryUrl({
+  apiBaseUrl,
+  connectionName
+}) {
+  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;
+
+const DEFAULT_HEADERS = {
+  Accept: 'application/json',
+  'Content-Type': 'application/json'
+};
+const REQUEST_CACHE = new Map();
+async function requestWithParameters({
+  baseUrl,
+  parameters = {},
+  headers: customHeaders = {},
+  errorContext,
+  maxLengthURL = DEFAULT_MAX_LENGTH_URL
+}) {
+  // Parameters added to all requests issued with `requestWithParameters()`.
+  // These parameters override parameters already in the base URL, but not
+  // user-provided parameters.
+  parameters = _extends({
+    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 REQUEST_CACHE.get(key);
+  }
+  const url = createURLWithParameters(baseUrl, parameters);
+  const headers = _extends({}, 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 jsonPromise;
+}
+function createCacheKey(baseUrl, parameters, headers) {
+  const parameterEntries = Object.entries(parameters).sort(([a], [b]) => a > b ? 1 : -1);
+  const headerEntries = Object.entries(headers).sort(([a], [b]) => 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();
+}
+
+const _excluded = ["accessToken", "connectionName", "cache"];
+const SOURCE_DEFAULTS = {
+  apiBaseUrl: DEFAULT_API_BASE_URL,
+  clientId: DEFAULT_CLIENT,
+  format: 'tilejson',
+  headers: {},
+  maxLengthURL: DEFAULT_MAX_LENGTH_URL
+};
+async function baseSource(endpoint, options, urlParameters) {
+  const {
+      accessToken,
+      connectionName,
+      cache
+    } = options,
+    optionalOptions = _objectWithoutPropertiesLoose(options, _excluded);
+  const mergedOptions = _extends({}, 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 = _extends({
+    Authorization: `Bearer ${options.accessToken}`
+  }, options.headers);
+  const parameters = _extends({
+    client: clientId
+  }, urlParameters);
+  const errorContext = {
+    requestType: 'Map instantiation',
+    connection: options.connectionName,
+    type: endpoint,
+    source: JSON.stringify(parameters, undefined, 2)
+  };
+  const mapInstantiation = await requestWithParameters({
+    baseUrl,
+    parameters,
+    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';
+  if (format === 'tilejson') {
+    const json = await requestWithParameters({
+      baseUrl: dataUrl,
+      headers,
+      errorContext,
+      maxLengthURL
+    });
+    if (accessToken) {
+      json.accessToken = accessToken;
+    }
+    return json;
+  }
+  return await requestWithParameters({
+    baseUrl: dataUrl,
+    headers,
+    errorContext,
+    maxLengthURL
+  });
+}
+
+// deck.gl
+const boundaryQuerySource = async function boundaryQuerySource(options) {
+  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 baseSource('boundary', options, urlParameters);
+};
+
+// deck.gl
+const boundaryTableSource = async function boundaryTableSource(options) {
+  const {
+    filters,
+    tilesetTableName,
+    columns,
+    propertiesTableName
+  } = options;
+  const urlParameters = {
+    tilesetTableName,
+    propertiesTableName
+  };
+  if (columns) {
+    urlParameters.columns = columns.join(',');
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  return baseSource('boundary', options, urlParameters);
+};
+
+// deck.gl
+const h3QuerySource$1 = async function h3QuerySource(options) {
+  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 baseSource('query', options, urlParameters);
+};
+
+// deck.gl
+const h3TableSource$1 = async function h3TableSource(options) {
+  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 baseSource('table', options, urlParameters);
+};
+
+// deck.gl
+const h3TilesetSource = async function h3TilesetSource(options) {
+  const {
+    tableName
+  } = options;
+  const urlParameters = {
+    name: tableName
+  };
+  return baseSource('tileset', options, urlParameters);
+};
+
+// deck.gl
+const rasterSource = async function rasterSource(options) {
+  const {
+    tableName,
+    filters
+  } = options;
+  const urlParameters = {
+    name: tableName
+  };
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  return baseSource('raster', options, urlParameters);
+};
+
+// deck.gl
+const quadbinQuerySource$1 = async function quadbinQuerySource(options) {
+  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 baseSource('query', options, urlParameters);
+};
+
+// deck.gl
+const quadbinTableSource$1 = async function quadbinTableSource(options) {
+  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 baseSource('table', options, urlParameters);
+};
+
+// deck.gl
+const quadbinTilesetSource = async function quadbinTilesetSource(options) {
+  const {
+    tableName
+  } = options;
+  const urlParameters = {
+    name: tableName
+  };
+  return baseSource('tileset', options, urlParameters);
+};
+
+// deck.gl
+const vectorQuerySource$1 = async function vectorQuerySource(options) {
+  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 baseSource('query', options, urlParameters);
+};
+
+// deck.gl
+const vectorTableSource$1 = async function vectorTableSource(options) {
+  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 baseSource('table', options, urlParameters);
+};
+
+// deck.gl
+const vectorTilesetSource = async function vectorTilesetSource(options) {
+  const {
+    tableName
+  } = options;
+  const urlParameters = {
+    name: tableName
+  };
+  return baseSource('tileset', options, urlParameters);
+};
+
 /** Wrapper adding Widget API support to [vectorTableSource](https://deck.gl/docs/api-reference/carto/data-sources). */
 async function vectorTableSource(props) {
-  assignDefaultProps(props);
   const response = await vectorTableSource$1(props);
   return _extends({}, response, {
     widgetSource: new WidgetTableSource(props)
@@ -932,7 +1453,6 @@ async function vectorTableSource(props) {
 }
 /** Wrapper adding Widget API support to [vectorQuerySource](https://deck.gl/docs/api-reference/carto/data-sources). */
 async function vectorQuerySource(props) {
-  assignDefaultProps(props);
   const response = await vectorQuerySource$1(props);
   return _extends({}, response, {
     widgetSource: new WidgetQuerySource(props)
@@ -940,7 +1460,6 @@ async function vectorQuerySource(props) {
 }
 /** Wrapper adding Widget API support to [h3TableSource](https://deck.gl/docs/api-reference/carto/data-sources). */
 async function h3TableSource(props) {
-  assignDefaultProps(props);
   const response = await h3TableSource$1(props);
   return _extends({}, response, {
     widgetSource: new WidgetTableSource(props)
@@ -948,7 +1467,6 @@ async function h3TableSource(props) {
 }
 /** Wrapper adding Widget API support to [h3QuerySource](https://deck.gl/docs/api-reference/carto/data-sources). */
 async function h3QuerySource(props) {
-  assignDefaultProps(props);
   const response = await h3QuerySource$1(props);
   return _extends({}, response, {
     widgetSource: new WidgetQuerySource(props)
@@ -956,7 +1474,6 @@ async function h3QuerySource(props) {
 }
 /** Wrapper adding Widget API support to [quadbinTableSource](https://deck.gl/docs/api-reference/carto/data-sources). */
 async function quadbinTableSource(props) {
-  assignDefaultProps(props);
   const response = await quadbinTableSource$1(props);
   return _extends({}, response, {
     widgetSource: new WidgetTableSource(props)
@@ -964,20 +1481,51 @@ async function quadbinTableSource(props) {
 }
 /** Wrapper adding Widget API support to [quadbinQuerySource](https://deck.gl/docs/api-reference/carto/data-sources). */
 async function quadbinQuerySource(props) {
-  assignDefaultProps(props);
   const response = await quadbinQuerySource$1(props);
   return _extends({}, response, {
     widgetSource: new WidgetQuerySource(props)
   });
 }
-function assignDefaultProps(props) {
-  if (typeof deck !== 'undefined' && deck && deck.VERSION) {
-    props.clientId || (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;
+
+const query = async function query(options) {
+  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 = _extends({
+    Authorization: `Bearer ${options.accessToken}`
+  }, options.headers);
+  const parameters = _extends({
+    client: clientId
+  }, urlParameters);
+  const errorContext = {
+    requestType: 'SQL',
+    connection: options.connectionName,
+    type: 'query',
+    source: JSON.stringify(parameters, undefined, 2)
+  };
+  return await requestWithParameters({
+    baseUrl,
+    parameters,
+    headers,
+    errorContext,
+    maxLengthURL
+  });
+};
 
-export { API_CLIENT_VERSION, FilterType, WidgetBaseSource, WidgetQuerySource, WidgetTableSource, addFilter, clearFilters, createPolygonSpatialFilter, createViewportSpatialFilter, getClient, getFilter, h3QuerySource, h3TableSource, hasFilter, quadbinQuerySource, quadbinTableSource, removeFilter, setClient, vectorQuerySource, vectorTableSource };
+export { ApiVersion, CartoAPIError, DEFAULT_API_BASE_URL, DEFAULT_CLIENT, DEFAULT_GEO_COLUMN, DEFAULT_MAX_LENGTH_URL, DEFAULT_TILE_RESOLUTION, DEFAULT_TILE_SIZE, FilterType, SOURCE_DEFAULTS, WidgetBaseSource, WidgetQuerySource, WidgetTableSource, addFilter, boundaryQuerySource, boundaryTableSource, buildPublicMapUrl, buildStatsUrl, clearFilters, createPolygonSpatialFilter, createViewportSpatialFilter, getClient, getFilter, h3QuerySource, h3TableSource, h3TilesetSource, hasFilter, quadbinQuerySource, quadbinTableSource, quadbinTilesetSource, query, rasterSource, removeFilter, requestWithParameters, setClient, vectorQuerySource, vectorTableSource, vectorTilesetSource };
 //# sourceMappingURL=api-client.modern.js.map