@carto/api-client 0.0.1-0

package/build/api-client.cjs

@@ -0,0 +1,1202 @@
+const CLIENT_ID = 'carto-api-client';
+/** @internalRemarks Source: @carto/constants */
+exports.MapType = void 0;
+(function (MapType) {
+  MapType["TABLE"] = "table";
+  MapType["QUERY"] = "query";
+  MapType["TILESET"] = "tileset";
+})(exports.MapType || (exports.MapType = {}));
+/** @internalRemarks Source: @carto/constants */
+exports.ApiVersion = void 0;
+(function (ApiVersion) {
+  ApiVersion["V1"] = "v1";
+  ApiVersion["V2"] = "v2";
+  ApiVersion["V3"] = "v3";
+})(exports.ApiVersion || (exports.ApiVersion = {}));
+/** @internalRemarks Source: @carto/react-core */
+exports.GroupDateType = void 0;
+(function (GroupDateType) {
+  GroupDateType["YEARS"] = "year";
+  GroupDateType["MONTHS"] = "month";
+  GroupDateType["WEEKS"] = "week";
+  GroupDateType["DAYS"] = "day";
+  GroupDateType["HOURS"] = "hour";
+  GroupDateType["MINUTES"] = "minute";
+  GroupDateType["SECONDS"] = "second";
+})(exports.GroupDateType || (exports.GroupDateType = {}));
+/** @internalRemarks Source: @carto/react-api, @deck.gl/carto */
+exports.FilterType = void 0;
+(function (FilterType) {
+  FilterType["IN"] = "in";
+  /** [a, b] both are included. */
+  FilterType["BETWEEN"] = "between";
+  /** [a, b) a is included, b is not. */
+  FilterType["CLOSED_OPEN"] = "closed_open";
+  FilterType["TIME"] = "time";
+  FilterType["STRING_SEARCH"] = "stringSearch";
+})(exports.FilterType || (exports.FilterType = {}));
+
+/**
+ * Default client
+ * @internalRemarks Source: @carto/react-core
+ */
+let client = CLIENT_ID;
+/** @internalRemarks Source: @carto/react-core */
+function getClient() {
+  return client;
+}
+/** @internalRemarks Source: @carto/react-core */
+function setClient(c) {
+  client = c;
+}
+
+/**
+ * Threshold to use GET requests, vs POST
+ * @internalRemarks Source: @carto/constants
+ * @internal
+ */
+const REQUEST_GET_MAX_URL_LENGTH = 2048;
+/**
+ * @internalRemarks Source: @carto/constants
+ * @internal
+ */
+const DEFAULT_API_BASE_URL$1 = 'https://gcp-us-east1.api.carto.com';
+/**
+ * @internalRemarks Source: @carto/react-api
+ * @internal
+ */
+const DEFAULT_GEO_COLUMN = 'geom';
+
+const FILTER_TYPES = new Set(Object.values(exports.FilterType));
+const isFilterType = type => FILTER_TYPES.has(type);
+/**
+ * @privateRemarks Source: @carto/react-widgets
+ * @internal
+ */
+function getApplicableFilters(owner, filters) {
+  if (!filters) return {};
+  const applicableFilters = {};
+  for (const column in filters) {
+    for (const type in filters[column]) {
+      if (!isFilterType(type)) continue;
+      const filter = filters[column][type];
+      if (filter && filter.owner !== owner) {
+        applicableFilters[column] ||= {};
+        applicableFilters[column][type] = filter;
+      }
+    }
+  }
+  return applicableFilters;
+}
+/**
+ * Due to each data warehouse having its own behavior with columns,
+ * we need to normalize them and transform every key to lowercase.
+ *
+ * @internalRemarks Source: @carto/react-widgets
+ * @internal
+ */
+function normalizeObjectKeys(el) {
+  if (Array.isArray(el)) {
+    return el.map(value => normalizeObjectKeys(value));
+  } else if (typeof el !== 'object') {
+    return el;
+  }
+  return Object.entries(el).reduce((acc, _ref) => {
+    let [key, value] = _ref;
+    acc[key.toLowerCase()] = typeof value === 'object' && value ? normalizeObjectKeys(value) : value;
+    return acc;
+  }, {});
+}
+/** @internalRemarks Source: @carto/react-core */
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+/**
+ * @internalRemarks Source: @carto/react-core
+ * @internal
+ */
+class InvalidColumnError extends Error {
+  constructor(message) {
+    super(`${InvalidColumnError.NAME}: ${message}`);
+    this.name = InvalidColumnError.NAME;
+  }
+  static is(error) {
+    return error instanceof InvalidColumnError || error.message?.includes(InvalidColumnError.NAME);
+  }
+}
+InvalidColumnError.NAME = 'InvalidColumnError';
+
+/**
+ * Return more descriptive error from API
+ * @internalRemarks Source: @carto/react-api
+ */
+
+/** @internalRemarks Source: @carto/react-api */
+
+function _catch(body, recover) {
+  try {
+    var result = body();
+  } catch (e) {
+    return recover(e);
+  }
+  if (result && result.then) {
+    return result.then(void 0, recover);
+  }
+  return result;
+}
+const makeCall = function (_ref2) {
+  let {
+    url,
+    credentials,
+    opts
+  } = _ref2;
+  try {
+    let _exit;
+    function _temp2(_result) {
+      if (_exit) ;
+      if (!response.ok) {
+        dealWithApiError({
+          response,
+          data
+        });
+      }
+      return data;
+    }
+    let response;
+    let data;
+    const isPost = opts?.method === 'POST';
+    const _temp = _catch(function () {
+      return Promise.resolve(fetch(url.toString(), {
+        headers: {
+          Authorization: `Bearer ${credentials.accessToken}`,
+          ...(isPost ? {
+            'Content-Type': 'application/json'
+          } : {})
+        },
+        ...(isPost ? {
+          method: opts?.method,
+          body: opts?.body
+        } : {}),
+        signal: opts?.abortController?.signal,
+        ...opts?.otherOptions
+      })).then(function (_fetch) {
+        response = _fetch;
+        return Promise.resolve(response.json()).then(function (_response$json) {
+          data = _response$json;
+        });
+      });
+    }, function (error) {
+      if (error.name === 'AbortError') throw error;
+      throw new Error(`Failed request: ${error}`);
+    });
+    return Promise.resolve(_temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp));
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+function dealWithApiError(_ref) {
+  let {
+    response,
+    data
+  } = _ref;
+  if (data.error === 'Column not found') {
+    throw new InvalidColumnError(`${data.error} ${data.column_name}`);
+  }
+  if (data.error?.includes('Missing columns')) {
+    throw new InvalidColumnError(data.error);
+  }
+  switch (response.status) {
+    case 401:
+      throw new Error('Unauthorized access. Invalid credentials');
+    case 403:
+      throw new Error('Forbidden access to the requested data');
+    default:
+      const msg = data && data.error && typeof data.error === 'string' ? data.error : JSON.stringify(data?.hint || data.error?.[0]);
+      throw new Error(msg);
+  }
+}
+/** @internalRemarks Source: @carto/react-api */
+function checkCredentials(credentials) {
+  if (!credentials || !credentials.apiBaseUrl || !credentials.accessToken) {
+    throw new Error('Missing or bad credentials provided');
+  }
+}
+
+/** @internalRemarks Source: @carto/react-api */
+const AVAILABLE_MODELS = ['category', 'histogram', 'formula', 'timeseries', 'range', 'scatterplot', 'table'];
+/**
+ * Execute a SQL model request.
+ * @internalRemarks Source: @carto/react-api
+ */
+function executeModel(props) {
+  assert(props.source, 'executeModel: missing source');
+  assert(props.model, 'executeModel: missing model');
+  assert(props.params, 'executeModel: missing params');
+  assert(AVAILABLE_MODELS.indexOf(props.model) !== -1, `executeModel: model provided isn't valid. Available models: ${AVAILABLE_MODELS.join(', ')}`);
+  const {
+    source,
+    model,
+    params,
+    spatialFilter,
+    opts
+  } = props;
+  checkCredentials(source.credentials);
+  assert(source.credentials.apiVersion === exports.ApiVersion.V3, 'SQL Model API is a feature only available in CARTO 3.');
+  assert(source.type !== exports.MapType.TILESET, 'executeModel: Tileset not supported');
+  let url = `${source.credentials.apiBaseUrl}/v3/sql/${source.connection}/model/${model}`;
+  const {
+    filters,
+    filtersLogicalOperator = 'and',
+    data,
+    type
+  } = source;
+  const queryParameters = source.queryParameters ? JSON.stringify(source.queryParameters) : '';
+  const queryParams = {
+    type,
+    client: getClient(),
+    source: data,
+    params: JSON.stringify(params),
+    queryParameters,
+    filters: JSON.stringify(filters),
+    filtersLogicalOperator
+  };
+  // API supports multiple filters, we apply it only to geoColumn
+  const spatialFilters = spatialFilter ? {
+    [source.geoColumn ? source.geoColumn : DEFAULT_GEO_COLUMN]: spatialFilter
+  } : undefined;
+  if (spatialFilters) {
+    queryParams.spatialFilters = JSON.stringify(spatialFilters);
+  }
+  const urlWithSearchParams = url + '?' + new URLSearchParams(queryParams).toString();
+  const isGet = urlWithSearchParams.length <= REQUEST_GET_MAX_URL_LENGTH;
+  if (isGet) {
+    url = urlWithSearchParams;
+  } else {
+    // undo the JSON.stringify, @TODO find a better pattern
+    queryParams.params = params;
+    queryParams.filters = filters;
+    queryParams.queryParameters = source.queryParameters;
+    if (spatialFilters) {
+      queryParams.spatialFilters = spatialFilters;
+    }
+  }
+  return makeCall({
+    url,
+    credentials: source.credentials,
+    opts: {
+      ...opts,
+      method: isGet ? 'GET' : 'POST',
+      ...(!isGet && {
+        body: JSON.stringify(queryParams)
+      })
+    }
+  });
+}
+
+class WidgetBaseSource {
+  constructor(props) {
+    this.props = void 0;
+    this.credentials = void 0;
+    this.connectionName = void 0;
+    this.props = {
+      ...WidgetBaseSource.defaultProps,
+      ...props
+    };
+    this.connectionName = props.connectionName;
+    this.credentials = {
+      apiVersion: props.apiVersion || exports.ApiVersion.V3,
+      apiBaseUrl: props.apiBaseUrl || DEFAULT_API_BASE_URL$1,
+      clientId: props.clientId || getClient(),
+      accessToken: props.accessToken,
+      geoColumn: props.geoColumn || DEFAULT_GEO_COLUMN
+    };
+  }
+  getSource(owner) {
+    return {
+      ...this.props,
+      credentials: this.credentials,
+      connection: this.connectionName,
+      filters: getApplicableFilters(owner, this.props.filters)
+    };
+  }
+  getFormula(props) {
+    try {
+      const _this = this;
+      const {
+        filterOwner,
+        spatialFilter,
+        abortController,
+        operationExp,
+        ...params
+      } = props;
+      const {
+        column,
+        operation
+      } = params;
+      return Promise.resolve(executeModel({
+        model: 'formula',
+        source: _this.getSource(filterOwner),
+        spatialFilter,
+        params: {
+          column: column ?? '*',
+          operation,
+          operationExp
+        },
+        opts: {
+          abortController
+        }
+      }).then(res => normalizeObjectKeys(res.rows[0])));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  getCategories(props) {
+    try {
+      const _this2 = this;
+      const {
+        filterOwner,
+        spatialFilter,
+        abortController,
+        ...params
+      } = props;
+      const {
+        column,
+        operation,
+        operationColumn
+      } = params;
+      return Promise.resolve(executeModel({
+        model: 'category',
+        source: _this2.getSource(filterOwner),
+        spatialFilter,
+        params: {
+          column,
+          operation,
+          operationColumn: operationColumn || column
+        },
+        opts: {
+          abortController
+        }
+      }).then(res => normalizeObjectKeys(res.rows)));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  getRange(props) {
+    try {
+      const _this3 = this;
+      const {
+        filterOwner,
+        spatialFilter,
+        abortController,
+        ...params
+      } = props;
+      const {
+        column
+      } = params;
+      return Promise.resolve(executeModel({
+        model: 'range',
+        source: _this3.getSource(filterOwner),
+        spatialFilter,
+        params: {
+          column
+        },
+        opts: {
+          abortController
+        }
+      }).then(res => normalizeObjectKeys(res.rows[0])));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  getTable(props) {
+    try {
+      const _this4 = this;
+      const {
+        filterOwner,
+        spatialFilter,
+        abortController,
+        ...params
+      } = props;
+      const {
+        columns,
+        sortBy,
+        sortDirection,
+        page = 0,
+        rowsPerPage = 10
+      } = params;
+      return Promise.resolve(executeModel({
+        model: 'table',
+        source: _this4.getSource(filterOwner),
+        spatialFilter,
+        params: {
+          column: columns,
+          sortBy,
+          sortDirection,
+          limit: rowsPerPage,
+          offset: page * rowsPerPage
+        },
+        opts: {
+          abortController
+        }
+      }).then(res => ({
+        rows: normalizeObjectKeys(res.rows),
+        totalCount: res.metadata.total
+      })));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  getScatter(props) {
+    try {
+      const _this5 = this;
+      const {
+        filterOwner,
+        spatialFilter,
+        abortController,
+        ...params
+      } = props;
+      const {
+        xAxisColumn,
+        xAxisJoinOperation,
+        yAxisColumn,
+        yAxisJoinOperation
+      } = params;
+      // Make sure this is sync with the same constant in cloud-native/maps-api
+      const HARD_LIMIT = 500;
+      return Promise.resolve(executeModel({
+        model: 'scatterplot',
+        source: _this5.getSource(filterOwner),
+        spatialFilter,
+        params: {
+          xAxisColumn,
+          xAxisJoinOperation,
+          yAxisColumn,
+          yAxisJoinOperation,
+          limit: HARD_LIMIT
+        },
+        opts: {
+          abortController
+        }
+      }).then(res => normalizeObjectKeys(res.rows)).then(res => res.map(_ref => {
+        let {
+          x,
+          y
+        } = _ref;
+        return [x, y];
+      })));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  getTimeSeries(props) {
+    try {
+      const _this6 = this;
+      const {
+        filterOwner,
+        abortController,
+        spatialFilter,
+        ...params
+      } = props;
+      const {
+        column,
+        operationColumn,
+        joinOperation,
+        operation,
+        stepSize,
+        stepMultiplier,
+        splitByCategory,
+        splitByCategoryLimit,
+        splitByCategoryValues
+      } = params;
+      return Promise.resolve(executeModel({
+        model: 'timeseries',
+        source: _this6.getSource(filterOwner),
+        spatialFilter,
+        params: {
+          column,
+          stepSize,
+          stepMultiplier,
+          operationColumn: operationColumn || column,
+          joinOperation,
+          operation,
+          splitByCategory,
+          splitByCategoryLimit,
+          splitByCategoryValues
+        },
+        opts: {
+          abortController
+        }
+      }).then(res => ({
+        rows: normalizeObjectKeys(res.rows),
+        categories: res.metadata?.categories
+      })));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  getHistogram(props) {
+    try {
+      const _this7 = this;
+      const {
+        filterOwner,
+        spatialFilter,
+        abortController,
+        ...params
+      } = props;
+      const {
+        column,
+        operation,
+        ticks
+      } = params;
+      return Promise.resolve(executeModel({
+        model: 'histogram',
+        source: _this7.getSource(filterOwner),
+        spatialFilter,
+        params: {
+          column,
+          operation,
+          ticks
+        },
+        opts: {
+          abortController
+        }
+      }).then(res => normalizeObjectKeys(res.rows))).then(function (data) {
+        if (data.length) {
+          // Given N ticks the API returns up to N+1 bins, omitting any empty bins. Bins
+          // include 1 bin below the lowest tick, N-1 between ticks, and 1 bin above the highest tick.
+          const result = Array(ticks.length + 1).fill(0);
+          data.forEach(_ref2 => {
+            let {
+              tick,
+              value
+            } = _ref2;
+            return result[tick] = value;
+          });
+          return result;
+        }
+        return [];
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+}
+WidgetBaseSource.defaultProps = {
+  filters: {},
+  filtersLogicalOperator: 'and'
+};
+
+class WidgetQuerySource extends WidgetBaseSource {
+  getSource(owner) {
+    return {
+      ...super.getSource(owner),
+      type: exports.MapType.QUERY,
+      data: this.props.sqlQuery
+    };
+  }
+}
+
+class WidgetTableSource extends WidgetBaseSource {
+  getSource(owner) {
+    return {
+      ...super.getSource(owner),
+      type: exports.MapType.TABLE,
+      data: this.props.tableName
+    };
+  }
+}
+
+// loaders.gl
+const isObject = x => x !== null && typeof x === 'object';
+const isPureObject = x => isObject(x) && x.constructor === {}.constructor;
+
+const DEFAULT_TILE_RESOLUTION = 0.5;
+const DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
+const DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
+
+/**
+ *
+ * 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) {
+    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; // eslint-disable-line no-continue
+      message += `\n${formatErrorKey(key)}: ${errorContext[key]}`;
+    }
+    message += '\n';
+    super(message);
+    this.name = 'CartoAPIError';
+    this.response = response;
+    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());
+}
+
+const DEFAULT_API_BASE_URL = 'https://gcp-us-east1.api.carto.com';
+const DEFAULT_CLIENT = 'deck-gl-carto';
+const V3_MINOR_VERSION = '3.4';
+const MAX_GET_LENGTH = 8192;
+const DEFAULT_PARAMETERS = {
+  v: V3_MINOR_VERSION,
+  deckglVersion: "0.0.1-0"
+};
+const DEFAULT_HEADERS = {
+  Accept: 'application/json',
+  'Content-Type': 'application/json'
+};
+
+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);
+}
+function buildSourceUrl({
+  apiBaseUrl,
+  connectionName,
+  endpoint
+}) {
+  return buildV3Path(apiBaseUrl, 'v3', 'maps', connectionName, endpoint);
+}
+
+/**
+ * Simple encode parameter
+ */
+function encodeParameter(name, value) {
+  if (isPureObject(value) || Array.isArray(value)) {
+    return `${name}=${encodeURIComponent(JSON.stringify(value))}`;
+  }
+  return `${name}=${encodeURIComponent(value)}`;
+}
+const REQUEST_CACHE = new Map();
+async function requestWithParameters({
+  baseUrl,
+  parameters,
+  headers: customHeaders,
+  errorContext
+}) {
+  parameters = {
+    ...DEFAULT_PARAMETERS,
+    ...parameters
+  };
+  const key = createCacheKey(baseUrl, parameters || {}, customHeaders || {});
+  if (REQUEST_CACHE.has(key)) {
+    return REQUEST_CACHE.get(key);
+  }
+  const url = parameters ? createURLWithParameters(baseUrl, parameters) : baseUrl;
+  const headers = {
+    ...DEFAULT_HEADERS,
+    ...customHeaders
+  };
+  /* global fetch */
+  const fetchPromise = url.length > MAX_GET_LENGTH ? fetch(baseUrl, {
+    method: 'POST',
+    body: JSON.stringify(parameters),
+    headers
+  }) : fetch(url, {
+    headers
+  });
+  let response;
+  const jsonPromise = fetchPromise.then(_response => {
+    response = _response;
+    return response.json();
+  }).then(json => {
+    if (!response || !response.ok) {
+      throw new Error(json.error);
+    }
+    return json;
+  }).catch(error => {
+    REQUEST_CACHE.delete(key);
+    throw new CartoAPIError(error, errorContext, response);
+  });
+  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
+  });
+}
+function createURLWithParameters(baseUrl, parameters) {
+  const encodedParameters = Object.entries(parameters).map(([key, value]) => encodeParameter(key, value));
+  return `${baseUrl}?${encodedParameters.join('&')}`;
+}
+
+/* eslint-disable camelcase */
+const SOURCE_DEFAULTS = {
+  apiBaseUrl: DEFAULT_API_BASE_URL,
+  clientId: DEFAULT_CLIENT,
+  format: 'tilejson',
+  headers: {}
+};
+async function baseSource(endpoint, options, urlParameters) {
+  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,
+    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)
+  };
+  const mapInstantiation = await requestWithParameters({
+    baseUrl,
+    parameters,
+    headers,
+    errorContext
+  });
+  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
+    });
+    if (accessToken) {
+      json.accessToken = accessToken;
+    }
+    return json;
+  }
+  return await requestWithParameters({
+    baseUrl: dataUrl,
+    headers,
+    errorContext
+  });
+}
+
+const boundaryQuerySource = async function (options) {
+  const {
+    columns,
+    filters,
+    tilesetTableName,
+    matchingColumn = 'id',
+    propertiesSqlQuery,
+    queryParameters
+  } = options;
+  const urlParameters = {
+    tilesetTableName,
+    matchingColumn,
+    propertiesSqlQuery
+  };
+  if (columns) {
+    urlParameters.columns = columns.join(',');
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  if (queryParameters) {
+    urlParameters.queryParameters = queryParameters;
+  }
+  return baseSource('boundary', options, urlParameters);
+};
+
+const boundaryTableSource = async function (options) {
+  const {
+    filters,
+    tilesetTableName,
+    columns,
+    matchingColumn = 'id',
+    propertiesTableName
+  } = options;
+  const urlParameters = {
+    tilesetTableName,
+    matchingColumn,
+    propertiesTableName
+  };
+  if (columns) {
+    urlParameters.columns = columns.join(',');
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  return baseSource('boundary', options, urlParameters);
+};
+
+/* eslint-disable camelcase */
+const h3QuerySource$1 = async function (options) {
+  const {
+    aggregationExp,
+    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3,
+    sqlQuery,
+    spatialDataColumn = 'h3',
+    queryParameters
+  } = options;
+  const urlParameters = {
+    aggregationExp,
+    spatialDataColumn,
+    spatialDataType: 'h3',
+    q: sqlQuery
+  };
+  if (aggregationResLevel) {
+    urlParameters.aggregationResLevel = String(aggregationResLevel);
+  }
+  if (queryParameters) {
+    urlParameters.queryParameters = queryParameters;
+  }
+  return baseSource('query', options, urlParameters);
+};
+
+/* eslint-disable camelcase */
+const h3TableSource$1 = async function (options) {
+  const {
+    aggregationExp,
+    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3,
+    spatialDataColumn = 'h3',
+    tableName
+  } = options;
+  const urlParameters = {
+    aggregationExp,
+    name: tableName,
+    spatialDataColumn,
+    spatialDataType: 'h3'
+  };
+  if (aggregationResLevel) {
+    urlParameters.aggregationResLevel = String(aggregationResLevel);
+  }
+  return baseSource('table', options, urlParameters);
+};
+
+const h3TilesetSource$1 = async function (options) {
+  const {
+    tableName
+  } = options;
+  const urlParameters = {
+    name: tableName
+  };
+  return baseSource('tileset', options, urlParameters);
+};
+
+const rasterSource = async function (options) {
+  const {
+    tableName
+  } = options;
+  const urlParameters = {
+    name: tableName
+  };
+  return baseSource('raster', options, urlParameters);
+};
+
+/* eslint-disable camelcase */
+const quadbinQuerySource$1 = async function (options) {
+  const {
+    aggregationExp,
+    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
+    sqlQuery,
+    spatialDataColumn = 'quadbin',
+    queryParameters
+  } = options;
+  const urlParameters = {
+    aggregationExp,
+    q: sqlQuery,
+    spatialDataColumn,
+    spatialDataType: 'quadbin'
+  };
+  if (aggregationResLevel) {
+    urlParameters.aggregationResLevel = String(aggregationResLevel);
+  }
+  if (queryParameters) {
+    urlParameters.queryParameters = queryParameters;
+  }
+  return baseSource('query', options, urlParameters);
+};
+
+/* eslint-disable camelcase */
+const quadbinTableSource$1 = async function (options) {
+  const {
+    aggregationExp,
+    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
+    spatialDataColumn = 'quadbin',
+    tableName
+  } = options;
+  const urlParameters = {
+    aggregationExp,
+    name: tableName,
+    spatialDataColumn,
+    spatialDataType: 'quadbin'
+  };
+  if (aggregationResLevel) {
+    urlParameters.aggregationResLevel = String(aggregationResLevel);
+  }
+  return baseSource('table', options, urlParameters);
+};
+
+const quadbinTilesetSource$1 = async function (options) {
+  const {
+    tableName
+  } = options;
+  const urlParameters = {
+    name: tableName
+  };
+  return baseSource('tileset', options, urlParameters);
+};
+
+/* eslint-disable camelcase */
+const vectorQuerySource$1 = async function (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);
+};
+
+/* eslint-disable camelcase */
+const vectorTableSource$1 = async function (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);
+};
+
+const vectorTilesetSource$1 = async function (options) {
+  const {
+    tableName
+  } = options;
+  const urlParameters = {
+    name: tableName
+  };
+  return baseSource('tileset', options, urlParameters);
+};
+
+({
+  boundaryQuerySource,
+  boundaryTableSource,
+  h3QuerySource: h3QuerySource$1,
+  h3TableSource: h3TableSource$1,
+  h3TilesetSource: h3TilesetSource$1,
+  rasterSource,
+  quadbinQuerySource: quadbinQuerySource$1,
+  quadbinTableSource: quadbinTableSource$1,
+  quadbinTilesetSource: quadbinTilesetSource$1,
+  vectorQuerySource: vectorQuerySource$1,
+  vectorTableSource: vectorTableSource$1,
+  vectorTilesetSource: vectorTilesetSource$1
+});
+
+/******************************************************************************
+ * VECTOR SOURCES
+ */
+/** Wrapper adding widget support to {@link _vectorTableSource}. */
+
+/** Wrapper adding widget support to {@link _quadbinTilesetSource}. */
+const quadbinTilesetSource = function () {
+  try {
+    throw new Error('not implemented');
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+/** Wrapper adding widget support to {@link _quadbinQuerySource}. */
+const quadbinQuerySource = function (props) {
+  try {
+    return Promise.resolve(quadbinQuerySource$1(props)).then(function (response) {
+      return {
+        ...response,
+        widgetSource: new WidgetQuerySource(props)
+      };
+    });
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+/******************************************************************************
+ * QUADBIN SOURCES
+ */
+/** Wrapper adding widget support to {@link _quadbinTableSource}. */
+const quadbinTableSource = function (props) {
+  try {
+    return Promise.resolve(quadbinTableSource$1(props)).then(function (response) {
+      return {
+        ...response,
+        widgetSource: new WidgetTableSource(props)
+      };
+    });
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+/** Wrapper adding widget support to {@link _h3TilesetSource}. */
+const h3TilesetSource = function () {
+  try {
+    throw new Error('not implemented');
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+/** Wrapper adding widget support to {@link _h3QuerySource}. */
+const h3QuerySource = function (props) {
+  try {
+    return Promise.resolve(h3QuerySource$1(props)).then(function (response) {
+      return {
+        ...response,
+        widgetSource: new WidgetQuerySource(props)
+      };
+    });
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+/******************************************************************************
+ * H3 SOURCES
+ */
+/** Wrapper adding widget support to {@link _h3TableSource}. */
+const h3TableSource = function (props) {
+  try {
+    return Promise.resolve(h3TableSource$1(props)).then(function (response) {
+      return {
+        ...response,
+        widgetSource: new WidgetTableSource(props)
+      };
+    });
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+/** Wrapper adding widget support to {@link _vectorTilesetSource}. */
+const vectorTilesetSource = function () {
+  try {
+    throw new Error('not implemented');
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+/** Wrapper adding widget support to {@link _vectorQuerySource}. */
+const vectorQuerySource = function (props) {
+  try {
+    return Promise.resolve(vectorQuerySource$1(props)).then(function (response) {
+      return {
+        ...response,
+        widgetSource: new WidgetQuerySource(props)
+      };
+    });
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+const vectorTableSource = function (props) {
+  try {
+    return Promise.resolve(vectorTableSource$1(props)).then(function (response) {
+      return {
+        ...response,
+        widgetSource: new WidgetTableSource(props)
+      };
+    });
+  } catch (e) {
+    return Promise.reject(e);
+  }
+};
+
+exports.CLIENT_ID = CLIENT_ID;
+exports.WidgetBaseSource = WidgetBaseSource;
+exports.WidgetQuerySource = WidgetQuerySource;
+exports.WidgetTableSource = WidgetTableSource;
+exports.executeModel = executeModel;
+exports.getClient = getClient;
+exports.h3QuerySource = h3QuerySource;
+exports.h3TableSource = h3TableSource;
+exports.h3TilesetSource = h3TilesetSource;
+exports.quadbinQuerySource = quadbinQuerySource;
+exports.quadbinTableSource = quadbinTableSource;
+exports.quadbinTilesetSource = quadbinTilesetSource;
+exports.setClient = setClient;
+exports.vectorQuerySource = vectorQuerySource;
+exports.vectorTableSource = vectorTableSource;
+exports.vectorTilesetSource = vectorTilesetSource;
+//# sourceMappingURL=api-client.cjs.map