@vizzly/dashboard 0.15.0-dev-641cbfac7b4b489d218fea2f77a8c1c3eb2b0d96 → 0.15.0-dev-9ba9cfcf5d6fdab60b458c0b97e98590696c65ea

package/dist/dashboard.cjs.development.js

@@ -10,8 +10,8 @@ var isEmpty$2 = _interopDefault(require('lodash/isEmpty'));
 var _ = require('lodash');
 var ___default = _interopDefault(_);
 var semanticLayerPublic = require('@vizzly/semantic-layer-public');
-var Joi = _interopDefault(require('@vizzly/joi'));
 var moment = _interopDefault(require('moment-timezone'));
+var Joi = _interopDefault(require('@vizzly/joi'));
 var uuid = require('uuid');
 var react = require('@emotion/react');
 var jsxRuntime = require('@emotion/react/jsx-runtime');
@@ -1212,6 +1212,35 @@ function extractValue(variables, key) {
   return variables[key].value;
 }
 
+var getUTCDate = function getUTCDate(date) {
+  if (date !== null) {
+    var momentDate = moment(new Date(date));
+    return momentDate.tz(Intl.DateTimeFormat().resolvedOptions().timeZone)._d;
+  }
+  return date;
+};
+
+var filterIsDate = function filterIsDate(filter) {
+  var isoDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+  if (!isoDateRegex.test(filter.value)) {
+    return false;
+  }
+  var date = new Date(filter.value);
+  if (isNaN(date.getTime())) {
+    return false;
+  }
+
+  // Additional check to verify that the date parts match exactly
+  var _filter$value$split$ = filter.value.split('T')[0].split('-').map(Number),
+    year = _filter$value$split$[0],
+    month = _filter$value$split$[1],
+    day = _filter$value$split$[2];
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() + 1 !== month || date.getUTCDate() !== day) {
+    return false;
+  }
+  return true;
+};
+
 var _Joi$string, _Joi$string2;
 var defaultDurationOptions = function defaultDurationOptions(textOverride) {
   return {
@@ -1324,6 +1353,175 @@ var buildRelativeRange = function buildRelativeRange(relativeFilters, dataSet, a
   });
 };
 
+var addAndFilters = function addAndFilters(filter, filterToAddToAll) {
+  if (_.isEmpty(filterToAddToAll)) return [].concat(filter);
+  if (!filter || _.isEmpty(filter)) filter = [[]];
+  var result = [];
+  for (var _iterator = _createForOfIteratorHelperLoose(filterToAddToAll), _step; !(_step = _iterator()).done;) {
+    var additionalAndFilter = _step.value;
+    for (var _iterator2 = _createForOfIteratorHelperLoose(filter), _step2; !(_step2 = _iterator2()).done;) {
+      var andFilter = _step2.value;
+      var combined = [].concat(additionalAndFilter, andFilter);
+      if (!_.isEmpty(combined)) {
+        result.push(combined);
+      }
+    }
+  }
+  return result;
+};
+var convertSingleFilterToRecursiveFilter = function convertSingleFilterToRecursiveFilter(filter, variables) {
+  var field = {
+    type: 'field',
+    value: filter.field,
+    "function": filter["function"] || 'none'
+  };
+  if ((filter.op === 'array_contains' || filter.op === 'array_does_not_contain') && Array.isArray(filter.value)) {
+    return {
+      type: 'andWhere',
+      value: filter.value.map(function (value) {
+        return {
+          type: 'where',
+          value: {
+            field: field,
+            op: filter.op,
+            value: value
+          }
+        };
+      })
+    };
+  }
+  var value = useValue(filter.value, variables);
+  if (isRelativeDateDefined(filter.value)) {
+    value = calculateRelativeDate(filter.value);
+  }
+  if (filterIsDate(filter)) {
+    value = getUTCDate(filter.value);
+  }
+  return {
+    type: 'where',
+    value: {
+      field: field,
+      op: filter.op,
+      value: value
+    }
+  };
+};
+var convertArrayFilterStructureToQueryFilter = function convertArrayFilterStructureToQueryFilter(arrayFilterStructure, variables) {
+  if (!Array.isArray(arrayFilterStructure)) {
+    return arrayFilterStructure;
+  }
+  if (arrayFilterStructure.length === 0 || arrayFilterStructure.every(function (andFilters) {
+    return andFilters.length === 0;
+  })) {
+    return {
+      type: 'andWhere',
+      value: []
+    };
+  }
+  var convertedAndGroups = arrayFilterStructure.filter(function (andFilters) {
+    return andFilters.length > 0;
+  }).map(function (andFilters) {
+    return {
+      type: 'andWhere',
+      value: andFilters.map(function (filter) {
+        return convertSingleFilterToRecursiveFilter(filter, variables);
+      })
+    };
+  });
+  if (convertedAndGroups.length === 1) {
+    return convertedAndGroups[0];
+  }
+  return {
+    type: 'orWhere',
+    value: convertedAndGroups
+  };
+};
+var combineQueryFilters = function combineQueryFilters(filter, filterToAddToAll) {
+  if (Array.isArray(filter.value) && filter.value.length === 0) {
+    return filterToAddToAll;
+  }
+  if (Array.isArray(filterToAddToAll.value) && filterToAddToAll.value.length === 0) {
+    return filter;
+  }
+  return {
+    type: 'andWhere',
+    value: [filter, filterToAddToAll]
+  };
+};
+
+/**
+ * Iterates through a query filter and, for each custom metric field, builds a custom metric.
+ */
+function buildQueryCustomMetrics(filter, dataSet, queryEngineConfig, params) {
+  if (filter.type === 'where') {
+    var field = getFieldFromFilter(filter);
+    if (!field) return filter;
+    var dataSetField = findField(dataSet, field.value);
+    var fieldFunction = 'function' in field && !!field["function"] ? field["function"] : 'none';
+    if (isCustomField(dataSetField)) {
+      var customField = toQueryMeasure({
+        field: dataSetField.id,
+        "function": fieldFunction
+      }, dataSetField, queryEngineConfig, dataSet, false, params);
+      return {
+        type: 'where',
+        value: {
+          field: customField,
+          op: filter.value.op,
+          value: filter.value.value
+        }
+      };
+    }
+    return filter;
+  }
+  if (filter.type === 'andWhere' || filter.type === 'orWhere') {
+    var processedValues = filter.value.map(function (f) {
+      return buildQueryCustomMetrics(f, dataSet, queryEngineConfig, params);
+    });
+    return {
+      type: filter.type,
+      value: processedValues
+    };
+  }
+  return filter;
+}
+function getFieldFromFilter(filter) {
+  if (filter.type === 'where') {
+    if ('value' in filter.value.field && typeof filter.value.field.value === 'string') {
+      return filter.value.field;
+    }
+  }
+  return null;
+}
+var isAvailable = function isAvailable(filter) {
+  return filter && _.isArray(filter) && _.isArray(filter[0]);
+};
+var isAdditionalFilter = function isAdditionalFilter(value) {
+  return value && _.isArray(value) && _.isArray(value[0]) && 'field' in value[0][0] && 'op' in value[0][0] && 'value' in value[0][0];
+};
+
+var combineFilters = function combineFilters(array1, array2) {
+  var validArray1 = array1.length > 0 && array1[0] ? array1 : [[]];
+  var validArray2 = array2.length > 0 && array2[0] ? array2 : [[]];
+
+  // If array1 has more than one sub-array, loop through each sub-array in array1
+  if (validArray1.length > 1) {
+    return validArray1.map(function (subArray) {
+      return [].concat(validArray2[0] || [], subArray || []);
+    });
+  }
+  // Otherwise, if array2 has more than one sub-array, loop through array2
+  else if (validArray2.length > 1) {
+    return validArray2.map(function (subArray) {
+      return [].concat(validArray1[0] || [], subArray || []);
+    });
+  }
+  // Default: merge both single sub-arrays
+  else {
+    return [[].concat(validArray1[0] || [], validArray2[0] || [])];
+  }
+};
+
 /** Upcasts from an old global filter, to a new "additional filter" */
 var upcastToAdditionalFilter = function upcastToAdditionalFilter(globalFilter) {
   if (globalFilter.type == 'globalSelectFilter') {
@@ -1375,105 +1573,6 @@ var MULTI_SELECT_FILTER = 'multiSelectFilter';
 var NUMERIC_FILTER = 'numericFilter';
 var ADVANCED_FILTER = 'advancedFilter';
 
-var getUTCDate = function getUTCDate(date) {
-  if (date !== null) {
-    var momentDate = moment(new Date(date));
-    return momentDate.tz(Intl.DateTimeFormat().resolvedOptions().timeZone)._d;
-  }
-  return date;
-};
-
-var toQueryAttributesFilter = function toQueryAttributesFilter(dataSet, filter, customTimeRangeFuncs) {
-  return filter.appliesToFields.flatMap(function (field) {
-    var _filter$value, _filter$value2, _filter$value3;
-    if (field.dataSetId != dataSet.id) return [];
-    if (filter.value == null) return [];
-    var dataSetField = findField(dataSet, field.fieldId);
-
-    // might be able to remove this
-    if (dataSetField.dataType == 'string[]' && filter.type !== MULTI_SELECT_FILTER && !isAdditionalFilter(filter.value)) {
-      return [[{
-        field: field.fieldId,
-        op: 'array_contains',
-        value: filter.value
-      }]];
-    }
-    if ((filter.type == DATE_FILTER || filter.type == DATE_AND_TIME_FILTER) && ((_filter$value = filter.value) == null ? void 0 : _filter$value.type) == 'relativeRange') {
-      return [];
-    }
-    if ((filter.type == DATE_FILTER || filter.type == DATE_AND_TIME_FILTER) && ((_filter$value2 = filter.value) == null ? void 0 : _filter$value2.type) == 'fixedRange') {
-      // We have a fixed time range, so we can use those values.
-
-      return [[{
-        field: field.fieldId,
-        op: inclusiveExclusiveCurrent(DateOp.Greater, filter),
-        value: getUTCDate(filter.value.after)
-      }, {
-        field: field.fieldId,
-        op: inclusiveExclusiveCurrent(DateOp.Less, filter),
-        value: getUTCDate(filter.value.before)
-      }]];
-    } else if ((filter.type == DATE_FILTER || filter.type == DATE_AND_TIME_FILTER) && ((_filter$value3 = filter.value) == null ? void 0 : _filter$value3.type) == 'relative') {
-      // We have a relative time filter, so need to call the time functions to get the values....
-
-      var _customTimeRangeFuncs = customTimeRangeFuncs[filter.value.value].range,
-        before = _customTimeRangeFuncs.before,
-        after = _customTimeRangeFuncs.after;
-      var filters = [[]];
-      if (before) {
-        filters = filters.map(function (f) {
-          return [].concat(f, [{
-            field: field.fieldId,
-            op: inclusiveExclusiveCurrent(DateOp.Less, filter),
-            value: before
-          }]);
-        });
-      }
-      if (after) {
-        filters = filters.map(function (f) {
-          return [].concat(f, [{
-            field: field.fieldId,
-            op: inclusiveExclusiveCurrent(DateOp.Greater, filter),
-            value: after
-          }]);
-        });
-      }
-      return filters;
-    } else if (filter.type == SINGLE_SELECT_FILTER) {
-      var value = filter.value;
-      if (filter.value === NULL_VALUE_OPT) {
-        value = null;
-      }
-      return [[{
-        field: field.fieldId,
-        op: '=',
-        value: value
-      }]];
-    } else if (isAdditionalFilter(filter.value)) {
-      return buildAdvancedFilters(filter.value, field, dataSet.id);
-    } else if (filter.type == MULTI_SELECT_FILTER && filter.value.length > 0) {
-      return [[{
-        field: field.fieldId,
-        op: 'is_one_of',
-        value: filter.value
-      }]];
-    } else if (filter.type == DATE_FILTER && !filter.value || filter.type == DATE_AND_TIME_FILTER && !filter.value || filter.type == MULTI_SELECT_FILTER && filter.value.length === 0) {
-      // No value set on the filter, so it cannot become a query attribute.
-      return [];
-    } else if (filter.type == NUMERIC_FILTER) {
-      if ('op' in filter.value && 'value' in filter.value) {
-        return [[{
-          field: field.fieldId,
-          op: filter.value.op,
-          value: filter.value.value
-        }]];
-      }
-      return [[]];
-    }
-    throw "Cannot convert filter type " + filter.type + " to query attributes filter. " + JSON.stringify(filter);
-  });
-};
-
 var typeToString = function typeToString(type, textOverride) {
   if (type == DATE_FILTER) return textOverride('date_filter', 'Date filter');
   if (type == DATE_AND_TIME_FILTER) return textOverride('date_time_filter', 'Date Time filter');
@@ -1676,31 +1775,48 @@ function inclusiveExclusiveCurrent(op, filter) {
       throw new Error('Unknown date operation');
   }
 }
-function getCascadeOptionsFilters(globalFilters, dataSets, dateFilterOptions, cascadeFilterSelection) {
+function getCascadeOptionsFilters(globalFilters, dataSets, dateFilterOptions, variables, cascadeFilterSelection) {
   if (!cascadeFilterSelection) return undefined;
-  var result = globalFilters.reduce(function (acc, dataObj) {
-    if (dataObj.value !== null) {
-      if (Array.isArray(dataObj.value) && dataObj.value.length === 0) {
-        return acc;
+  var dataSetMap = new Map(dataSets.map(function (ds) {
+    return [ds.id, ds];
+  }));
+  var filtersByDataSet = globalFilters.reduce(function (acc, filter) {
+    if (!hasValidFilterValue(filter.value)) {
+      return acc;
+    }
+    var uniqueDataSetIds = new Set(filter.appliesToFields.map(function (f) {
+      return f.dataSetId;
+    }));
+    for (var _iterator = _createForOfIteratorHelperLoose(uniqueDataSetIds), _step; !(_step = _iterator()).done;) {
+      var dataSetId = _step.value;
+      var dataSet = dataSetMap.get(dataSetId);
+      if (!dataSet) continue;
+      if (!acc[dataSetId]) {
+        acc[dataSetId] = [];
       }
-      var uniqueDataSetIds = new Set(dataObj.appliesToFields.map(function (f) {
-        return f.dataSetId;
-      }));
-      uniqueDataSetIds.forEach(function (dataSetId) {
-        var dataSet = find(dataSets, dataSetId);
-        if (!acc[dataSetId]) {
-          acc[dataSetId] = [];
-        }
-        if (dataSet !== null) {
-          var filters = toQueryAttributesFilter(dataSet, dataObj, dateFilterOptions);
-          acc[dataSetId] = addAndFilters(acc[dataSetId], filters);
-        }
-      });
+      var queryFilters = processAdditionalFilter(filter, dataSet, dateFilterOptions, variables);
+      acc[dataSetId].push(queryFilters);
+    }
+    return acc;
+  }, {});
+  var result = Object.entries(filtersByDataSet).reduce(function (acc, _ref2) {
+    var dataSetId = _ref2[0],
+      filters = _ref2[1];
+    if (filters.length > 0) {
+      acc[dataSetId] = {
+        type: 'andWhere',
+        value: filters
+      };
     }
     return acc;
   }, {});
   return Object.keys(result).length === 0 ? undefined : result;
 }
+function hasValidFilterValue(value) {
+  if (value === null || value === undefined) return false;
+  if (Array.isArray(value) && value.length === 0) return false;
+  return true;
+}
 var updateFilterForOptionalPulledFromOptions = function updateFilterForOptionalPulledFromOptions(filter) {
   if (!('optionsPulledFrom' in filter)) return filter;
   if (!filter.optionsPulledFrom || filter.optionsPulledFrom.length === 0) {
@@ -1755,168 +1871,182 @@ function getFilterDataType(filter, dataSets) {
   return findField(dataSet, filter.appliesToFields[0].fieldId).dataType;
 }
 
-var fromFilterConfig = function fromFilterConfig(filterConfig, dataSet, timeRangeOptions) {
-  var filters = [];
-  (filterConfig.globalFilters || []).forEach(function (additionalFilter) {
-    var addFilter = [];
-    if (additionalFilter.type === DATE_AND_TIME_FILTER || additionalFilter.type === DATE_FILTER) {
-      addFilter = toRelativeQueryAttributesFilters(additionalFilter, dataSet);
+var toQueryAttributesFilter = function toQueryAttributesFilter(dataSet, filter, customTimeRangeFuncs) {
+  return filter.appliesToFields.flatMap(function (field) {
+    var _filter$value, _filter$value2, _filter$value3;
+    if (field.dataSetId != dataSet.id) return [];
+    if (filter.value == null) return [];
+    var dataSetField = findField(dataSet, field.fieldId);
+
+    // might be able to remove this
+    if (dataSetField.dataType == 'string[]' && filter.type !== MULTI_SELECT_FILTER && !isAdditionalFilter(filter.value)) {
+      return [[{
+        field: field.fieldId,
+        op: 'array_contains',
+        value: filter.value
+      }]];
     }
-    filters = addAndFilters(filters, addFilter);
-    filters = addAndFilters(filters, toQueryAttributesFilter(dataSet, additionalFilter, timeRangeOptions));
-  });
-  var localAdditionalFilters = Object.values(filterConfig.localFilters || {}).flat();
-  localAdditionalFilters.forEach(function (additionalFilter) {
-    var addFilter = [];
-    if (additionalFilter.type === DATE_AND_TIME_FILTER || additionalFilter.type === DATE_FILTER) {
-      addFilter = toRelativeQueryAttributesFilters(additionalFilter, dataSet);
+    if ((filter.type == DATE_FILTER || filter.type == DATE_AND_TIME_FILTER) && ((_filter$value = filter.value) == null ? void 0 : _filter$value.type) == 'relativeRange') {
+      return [];
     }
-    filters = addAndFilters(filters, addFilter);
-    filters = addAndFilters(filters, toQueryAttributesFilter(dataSet, additionalFilter, timeRangeOptions));
-  });
-  return filters;
-};
-
-var filterIsDate = function filterIsDate(filter) {
-  var isoDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
-  if (!isoDateRegex.test(filter.value)) {
-    return false;
-  }
-  var date = new Date(filter.value);
-  if (isNaN(date.getTime())) {
-    return false;
-  }
+    if ((filter.type == DATE_FILTER || filter.type == DATE_AND_TIME_FILTER) && ((_filter$value2 = filter.value) == null ? void 0 : _filter$value2.type) == 'fixedRange') {
+      // We have a fixed time range, so we can use those values.
 
-  // Additional check to verify that the date parts match exactly
-  var _filter$value$split$ = filter.value.split('T')[0].split('-').map(Number),
-    year = _filter$value$split$[0],
-    month = _filter$value$split$[1],
-    day = _filter$value$split$[2];
-  if (date.getUTCFullYear() !== year || date.getUTCMonth() + 1 !== month || date.getUTCDate() !== day) {
-    return false;
-  }
-  return true;
-};
+      return [[{
+        field: field.fieldId,
+        op: inclusiveExclusiveCurrent(DateOp.Greater, filter),
+        value: getUTCDate(filter.value.after)
+      }, {
+        field: field.fieldId,
+        op: inclusiveExclusiveCurrent(DateOp.Less, filter),
+        value: getUTCDate(filter.value.before)
+      }]];
+    } else if ((filter.type == DATE_FILTER || filter.type == DATE_AND_TIME_FILTER) && ((_filter$value3 = filter.value) == null ? void 0 : _filter$value3.type) == 'relative') {
+      // We have a relative time filter, so need to call the time functions to get the values....
 
-var addAndFilters = function addAndFilters(filter, filterToAddToAll) {
-  if (_.isEmpty(filterToAddToAll)) return [].concat(filter);
-  if (!filter || _.isEmpty(filter)) filter = [[]];
-  var result = [];
-  for (var _iterator = _createForOfIteratorHelperLoose(filterToAddToAll), _step; !(_step = _iterator()).done;) {
-    var additionalAndFilter = _step.value;
-    for (var _iterator2 = _createForOfIteratorHelperLoose(filter), _step2; !(_step2 = _iterator2()).done;) {
-      var andFilter = _step2.value;
-      var combined = [].concat(additionalAndFilter, andFilter);
-      if (!_.isEmpty(combined)) {
-        result.push(combined);
+      var _customTimeRangeFuncs = customTimeRangeFuncs[filter.value.value].range,
+        before = _customTimeRangeFuncs.before,
+        after = _customTimeRangeFuncs.after;
+      var filters = [[]];
+      if (before) {
+        filters = filters.map(function (f) {
+          return [].concat(f, [{
+            field: field.fieldId,
+            op: inclusiveExclusiveCurrent(DateOp.Less, filter),
+            value: before
+          }]);
+        });
+      }
+      if (after) {
+        filters = filters.map(function (f) {
+          return [].concat(f, [{
+            field: field.fieldId,
+            op: inclusiveExclusiveCurrent(DateOp.Greater, filter),
+            value: after
+          }]);
+        });
+      }
+      return filters;
+    } else if (filter.type == SINGLE_SELECT_FILTER) {
+      var value = filter.value;
+      if (filter.value === NULL_VALUE_OPT) {
+        value = null;
       }
+      return [[{
+        field: field.fieldId,
+        op: '=',
+        value: value
+      }]];
+    } else if (isAdditionalFilter(filter.value)) {
+      return buildAdvancedFilters(filter.value, field, dataSet.id);
+    } else if (filter.type == MULTI_SELECT_FILTER && filter.value.length > 0) {
+      return [[{
+        field: field.fieldId,
+        op: 'is_one_of',
+        value: filter.value
+      }]];
+    } else if (filter.type == DATE_FILTER && !filter.value || filter.type == DATE_AND_TIME_FILTER && !filter.value || filter.type == MULTI_SELECT_FILTER && filter.value.length === 0) {
+      // No value set on the filter, so it cannot become a query attribute.
+      return [];
+    } else if (filter.type == NUMERIC_FILTER) {
+      if ('op' in filter.value && 'value' in filter.value) {
+        return [[{
+          field: field.fieldId,
+          op: filter.value.op,
+          value: filter.value.value
+        }]];
+      }
+      return [[]];
     }
-  }
-  return result;
+    throw "Cannot convert filter type " + filter.type + " to query attributes filter. " + JSON.stringify(filter);
+  });
 };
-var filterAttributeToQueryFilter = function filterAttributeToQueryFilter(filterAttrs, queryEngineConfig, dataSet, params) {
-  var _params$filterConfig;
-  // Either build using the filter attributes passed in, or take the viewFilters in the filter config.
-  // They represent the same thing, however some view-filters are passed around in the filter config
-  // to reduce custom metrics arguments being passed around.
-  var filter = filterAttrs.length > 0 && filterAttrs.some(function (group) {
-    return group.length > 0;
-  }) ? filterAttrs : ((_params$filterConfig = params.filterConfig) == null ? void 0 : _params$filterConfig.viewFilters) || [];
-  var extraFilters = fromFilterConfig(params.filterConfig, dataSet, params.timeRangeOptions);
-  var combinedFilters = addAndFilters(filter, extraFilters);
-  if (Array.isArray(filter)) {
-    return {
-      type: 'orWhere',
-      value: combinedFilters.map(function (andFilters) {
-        return {
-          type: 'andWhere',
-          value: andFilters.map(function (filter) {
-            var dataSetField = findField(dataSet, filter.field);
-            var field = {
-              type: 'field',
-              value: filter.field,
-              "function": filter["function"] || 'none'
-            };
-            if (isCustomField(dataSetField)) {
-              var _filter$function;
-              field = toQueryMeasure({
-                field: dataSetField.id,
-                "function": (_filter$function = filter["function"]) != null ? _filter$function : 'none'
-              }, dataSetField, queryEngineConfig, dataSet, false, params);
-            }
 
-            // If the value is an array, and we're checking that all values ARE or ARE NOT in a field, then we need to split
-            // out this check into multiple filters, as a value in a filter cannot be an array.
-            if ((filter.op == 'array_contains' || filter.op == 'array_does_not_contain') && Array.isArray(filter.value)) {
-              return {
-                type: 'andWhere',
-                value: [].concat(filter.value).map(function (value) {
-                  return {
-                    type: 'where',
-                    value: {
-                      field: field,
-                      op: filter.op,
-                      value: value
-                    }
-                  };
-                })
-              };
-            }
-            var value = useValue(filter.value, params.variables);
-            if (isRelativeDateDefined(filter.value)) {
-              value = calculateRelativeDate(filter.value);
-            }
-            if (filterIsDate(filter)) {
-              value = getUTCDate(filter.value);
-            }
-            return {
-              type: 'where',
-              value: {
-                field: field,
-                op: filter.op,
-                value: value
-              }
-            };
-          })
-        };
-      })
+var processAdditionalFilter = function processAdditionalFilter(filter, dataSet, timeRangeOptions, variables) {
+  var queryAttributesFilter = toQueryAttributesFilter(dataSet, filter, timeRangeOptions);
+  var convertedFilter = convertArrayFilterStructureToQueryFilter(queryAttributesFilter, variables);
+  if (filter.type === DATE_AND_TIME_FILTER || filter.type === DATE_FILTER) {
+    var relativeDateFilter = toRelativeQueryAttributesFilters(filter, dataSet);
+    var convertedRelativeFilter = convertArrayFilterStructureToQueryFilter(relativeDateFilter, variables);
+    return {
+      type: 'andWhere',
+      value: [convertedFilter, convertedRelativeFilter]
     };
   }
-  return filter;
-};
-var isAvailable = function isAvailable(filter) {
-  return filter && _.isArray(filter) && _.isArray(filter[0]);
+  return convertedFilter;
 };
-var isAdditionalFilter = function isAdditionalFilter(value) {
-  return value && _.isArray(value) && _.isArray(value[0]) && 'field' in value[0][0] && 'op' in value[0][0] && 'value' in value[0][0];
-};
-
-var combineFilters = function combineFilters(array1, array2) {
-  var validArray1 = array1.length > 0 && array1[0] ? array1 : [[]];
-  var validArray2 = array2.length > 0 && array2[0] ? array2 : [[]];
-
-  // If array1 has more than one sub-array, loop through each sub-array in array1
-  if (validArray1.length > 1) {
-    return validArray1.map(function (subArray) {
-      return [].concat(validArray2[0] || [], subArray || []);
-    });
-  }
-  // Otherwise, if array2 has more than one sub-array, loop through array2
-  else if (validArray2.length > 1) {
-    return validArray2.map(function (subArray) {
-      return [].concat(validArray1[0] || [], subArray || []);
+var isAdditionalFilterValid = function isAdditionalFilterValid(filter) {
+  if (Array.isArray(filter.value)) {
+    return filter.value.length > 0 && filter.value.some(function (item) {
+      return !Array.isArray(item) || item.length > 0;
     });
   }
-  // Default: merge both single sub-arrays
-  else {
-    return [[].concat(validArray1[0] || [], validArray2[0] || [])];
-  }
+  return Boolean(filter.value);
+};
+
+/**
+ * Combines different types of filters (global, local, and view filters) into a single Query filter structure.
+ *
+ * @param filterConfig - Configuration containing different filter types
+ * @param dataSet - Dataset to validate filters against
+ * @param timeRangeOptions - Time range configuration for date filters
+ * @param variables - Variable list for template substitution
+ * @returns Combined Query filter with proper AND/OR structure
+ */
+var combineFiltersFromFilterConfig = function combineFiltersFromFilterConfig(filterConfig, dataSet, timeRangeOptions, variables) {
+  var globalFilters = filterConfig.globalFilters || [];
+  var processedGlobalFilters = globalFilters.filter(isAdditionalFilterValid).map(function (filter) {
+    return processAdditionalFilter(filter, dataSet, timeRangeOptions, variables);
+  });
+  var localFilters = filterConfig.localFilters || [];
+  var processedLocalFilters = localFilters.filter(isAdditionalFilterValid).map(function (filter) {
+    return processAdditionalFilter(filter, dataSet, timeRangeOptions, variables);
+  });
+  var viewFilters = filterConfig.viewFilters ? filterConfig.viewFilters.filter(function (filter) {
+    return filter.length > 0;
+  }) : [];
+  var processedViewFilters = convertArrayFilterStructureToQueryFilter(viewFilters, variables);
+  var andFilters = [].concat(processedGlobalFilters, processedLocalFilters, [processedViewFilters]).filter(function (andFilter) {
+    if (Array.isArray(andFilter.value)) {
+      return andFilter.value.length > 0;
+    }
+    return true;
+  });
+  return {
+    type: 'andWhere',
+    value: andFilters
+  };
 };
 
 var generateId = function generateId() {
   return uuid.v4().replace(/-/g, '');
 };
 
+var Clause = /*#__PURE__*/function (Clause) {
+  Clause["AND_WHERE"] = "andWhere";
+  Clause["OR_WHERE"] = "orWhere";
+  Clause["WHERE"] = "where";
+  return Clause;
+}({});
+
+// export type WhereClause = SqlAST.MultiWhereToken<any>;
+
+var DEFAULT_ALWAYS_FILTER_VALUE = 2;
+var alwaysTrueFilter = {
+  type: Clause.AND_WHERE,
+  value: [{
+    type: Clause.WHERE,
+    value: {
+      field: {
+        type: 'number',
+        value: DEFAULT_ALWAYS_FILTER_VALUE
+      },
+      op: '=',
+      value: DEFAULT_ALWAYS_FILTER_VALUE
+    }
+  }]
+};
+
 /**
  * Creates a new custom percentage field.
  */
@@ -1941,10 +2071,15 @@ var init$1 = function init(publicName, denominatorFieldId, denominatorAggregate,
   };
 };
 var build$2 = function build(customField, queryEngineConfig, dataSet, _queryHasDimension, params) {
-  var _params$filterConfig$, _params$filterConfig, _customField$numerato, _customField$numerato2, _customField$denomina, _customField$denomina2;
-  var _buildPercentageFilte = buildPercentageFilters((_params$filterConfig$ = params == null || (_params$filterConfig = params.filterConfig) == null ? void 0 : _params$filterConfig.viewFilters) != null ? _params$filterConfig$ : [], customField),
-    combinedNominatorFilters = _buildPercentageFilte.combinedNominatorFilters,
-    combinedDenominatorFilters = _buildPercentageFilte.combinedDenominatorFilters;
+  var _customField$numerato, _customField$numerato2, _customField$denomina, _customField$denomina2;
+  var queryFiltersFromFilterConfig = combineFiltersFromFilterConfig(params.filterConfig, dataSet, params.timeRangeOptions, params.variables);
+  var _buildPercentageFilte = buildPercentageFilters(customField, params.variables),
+    queryFilterFromNumeratorFilter = _buildPercentageFilte.queryFilterFromNumeratorFilter,
+    queryFilterFromDenominatorFilter = _buildPercentageFilte.queryFilterFromDenominatorFilter;
+  var combinedNominatorFilters = combineQueryFilters(queryFiltersFromFilterConfig, queryFilterFromNumeratorFilter);
+  var combinedDenominatorFilters = combineQueryFilters(queryFiltersFromFilterConfig, queryFilterFromDenominatorFilter);
+  var completeNominatorFilters = buildQueryCustomMetrics(combinedNominatorFilters, dataSet, queryEngineConfig, params);
+  var completeDenominatorFilters = buildQueryCustomMetrics(combinedDenominatorFilters, dataSet, queryEngineConfig, params);
   var left = {
     fieldId: (_customField$numerato = customField.numeratorFieldId) != null ? _customField$numerato : customField.denominatorFieldId,
     aggregate: (_customField$numerato2 = customField.numeratorAggregate) != null ? _customField$numerato2 : customField.denominatorAggregate
@@ -1961,44 +2096,31 @@ var build$2 = function build(customField, queryEngineConfig, dataSet, _queryHasD
         value: customField.denominatorFieldId,
         "function": customField.denominatorAggregate
       }],
-      filter: filterAttributeToQueryFilter(combinedDenominatorFilters || [], queryEngineConfig, dataSet, params)
+      filter: completeDenominatorFilters
     }
   };
-  var denominatorForWithinGroupingScope = buildSide(right, isAvailable(customField.denominatorFilter) ? filterAttributeToQueryFilter(combinedDenominatorFilters, queryEngineConfig, dataSet, params) : {
+  var denominatorForWithinGroupingScope = buildSide(right, isAvailable(customField.denominatorFilter) ? completeDenominatorFilters : {
     type: 'andWhere',
     value: []
-  });
+  }, params.variables);
   return {
     type: 'maths',
-    left: buildSide(left, isAvailable(customField.numeratorFilter) ? filterAttributeToQueryFilter(combinedNominatorFilters, queryEngineConfig, dataSet, params) : {
+    left: buildSide(left, isAvailable(customField.numeratorFilter) ? completeNominatorFilters : {
       type: 'andWhere',
       value: []
-    }),
+    }, params.variables),
     op: '/',
     right: customField.denominatorScope === 'withinGrouping' ? denominatorForWithinGroupingScope : denominatorForAllScope
   };
 };
-var buildSide = function buildSide(field, filter) {
-  var alwaysTrueFilter = {
-    type: 'andWhere',
-    value: [{
-      type: 'where',
-      value: {
-        field: {
-          type: 'number',
-          value: 2
-        },
-        op: '=',
-        value: 2
-      }
-    }]
-  };
+var buildSide = function buildSide(field, filter, variables) {
+  var value = useValue(field.fieldId, variables);
   var hasNumeratorFilter = filter.type === 'where' || filter.value.length > 0;
   if (!hasNumeratorFilter) {
     return {
       type: 'field',
       "function": field.aggregate,
-      value: field.fieldId
+      value: value
     };
   } else {
     return {
@@ -2011,7 +2133,7 @@ var buildSide = function buildSide(field, filter) {
             returns: {
               type: 'field',
               "function": 'none',
-              value: field.fieldId
+              value: value
             },
             filter: filter
           }, {
@@ -2026,22 +2148,24 @@ var buildSide = function buildSide(field, filter) {
     };
   }
 };
-function buildPercentageFilters(filters, customField) {
-  var combinedNominatorFilters = [];
-  var combinedDenominatorFilters = [];
+function buildPercentageFilters(customField, variables) {
+  var queryFilterFromNumeratorFilter = {
+    type: 'andWhere',
+    value: []
+  };
+  var queryFilterFromDenominatorFilter = {
+    type: 'andWhere',
+    value: []
+  };
   if (customField.numeratorFilter && isAvailable(customField.numeratorFilter)) {
-    combinedNominatorFilters = addAndFilters(filters != null ? filters : [], customField.numeratorFilter);
-  } else {
-    combinedNominatorFilters = filters != null ? filters : [];
+    queryFilterFromNumeratorFilter = convertArrayFilterStructureToQueryFilter(customField.numeratorFilter, variables);
   }
   if (customField.denominatorFilter && isAvailable(customField.denominatorFilter)) {
-    combinedDenominatorFilters = addAndFilters(filters != null ? filters : [], customField.denominatorFilter);
-  } else {
-    combinedDenominatorFilters = filters != null ? filters : [];
+    queryFilterFromDenominatorFilter = convertArrayFilterStructureToQueryFilter(customField.denominatorFilter, variables);
   }
   return {
-    combinedNominatorFilters: combinedNominatorFilters,
-    combinedDenominatorFilters: combinedDenominatorFilters
+    queryFilterFromNumeratorFilter: queryFilterFromNumeratorFilter,
+    queryFilterFromDenominatorFilter: queryFilterFromDenominatorFilter
   };
 }
 
@@ -2089,10 +2213,7 @@ var buildSide$1 = function buildSide(value, dataSet, variables) {
       "function": 'none'
     };
   }
-  var valueAsString = value;
-  if (detect(value)) {
-    valueAsString = useValue(value, variables);
-  }
+  var valueAsString = useValue(value, variables);
   var valueAsNumber = Number(valueAsString);
   if (isNaN(valueAsNumber)) {
     var message = "Invalid number for Maths field: " + value + ".";
@@ -2126,35 +2247,36 @@ var init$3 = function init(publicName, leftFieldId, leftFunction, operator, righ
     rightNested: rightNested
   };
 };
-var build$4 = function build(customField) {
-  var buildSide = function buildSide(fieldId, func, nested) {
+var build$4 = function build(customField, variables) {
+  var buildSide = function buildSide(fieldId, func, variables, nested) {
+    var value = useValue(fieldId, variables);
     if (nested) {
+      var nestedValue = useValue(nested.fieldId, variables);
       return {
         type: 'maths',
         left: {
           type: 'field',
-          value: fieldId,
+          value: value,
           "function": func
         },
         right: {
           type: 'field',
-          value: nested.fieldId,
+          value: nestedValue,
           "function": nested["function"]
         },
         op: nested.operator
       };
-    } else {
-      return {
-        type: 'field',
-        value: fieldId,
-        "function": func
-      };
     }
+    return {
+      type: 'field',
+      value: value,
+      "function": func
+    };
   };
   return {
     type: 'maths',
-    left: buildSide(customField.leftFieldId, customField.leftFunction, customField.leftNested),
-    right: buildSide(customField.rightFieldId, customField.rightFunction, customField.rightNested),
+    left: buildSide(customField.leftFieldId, customField.leftFunction, variables, customField.leftNested),
+    right: buildSide(customField.rightFieldId, customField.rightFunction, variables, customField.rightNested),
     op: customField.operator
   };
 };
@@ -2175,14 +2297,9 @@ var init$4 = function init(publicName, fieldId, func, rule, queryEngineConfig) {
   };
 };
 var build$5 = function build(field, queryEngineConfig, dataSet, params) {
-  var alwaysTrueFilter = [[{
-    value: 1,
-    op: '=',
-    field: {
-      type: 'number',
-      value: 1
-    }
-  }]];
+  var queryFilterFromField = convertArrayFilterStructureToQueryFilter(field.rule, params.variables);
+  var completeFilters = buildQueryCustomMetrics(queryFilterFromField, dataSet, queryEngineConfig, params);
+  var value = useValue(field.fieldId, params.variables);
   return {
     type: 'function',
     "function": field["function"],
@@ -2193,9 +2310,9 @@ var build$5 = function build(field, queryEngineConfig, dataSet, params) {
           returns: {
             type: 'field',
             "function": 'none',
-            value: field.fieldId
+            value: value
           },
-          filter: filterAttributeToQueryFilter(field.rule, queryEngineConfig, dataSet, params)
+          filter: completeFilters
         }, {
           returns: {
             type: 'null'
@@ -2242,12 +2359,14 @@ var convertToCases = function convertToCases(rules, queryEngineConfig, dataSet,
   return rules.map(function (_ref) {
     var rule = _ref.rule,
       name = _ref.name;
+    var queryFilterFromRule = convertArrayFilterStructureToQueryFilter(rule, params.variables);
+    var completeFilters = buildQueryCustomMetrics(queryFilterFromRule, dataSet, queryEngineConfig, params);
     return {
       returns: {
         type: 'string',
         value: name
       },
-      filter: filterAttributeToQueryFilter(rule, queryEngineConfig, dataSet, params)
+      filter: completeFilters
     };
   });
 };
@@ -2267,7 +2386,9 @@ var init$6 = function init(publicName, leftFieldId, dateCalculationFunction, rig
     }, queryEngineConfig)
   };
 };
-var build$7 = function build(measureAttribute, customField) {
+var build$7 = function build(measureAttribute, customField, variables) {
+  var leftValue = useValue(customField.leftFieldId, variables);
+  var rightValue = useValue(customField.rightFieldId, variables);
   if (measureAttribute["function"] != 'none') {
     return {
       type: 'function',
@@ -2278,12 +2399,12 @@ var build$7 = function build(measureAttribute, customField) {
         left: {
           type: 'field',
           "function": 'none',
-          value: customField.leftFieldId
+          value: leftValue
         },
         right: {
           type: 'field',
           "function": 'none',
-          value: customField.rightFieldId
+          value: rightValue
         }
       }
     };
@@ -2294,12 +2415,12 @@ var build$7 = function build(measureAttribute, customField) {
       left: {
         type: 'field',
         "function": 'none',
-        value: customField.leftFieldId
+        value: leftValue
       },
       right: {
         type: 'field',
         "function": 'none',
-        value: customField.rightFieldId
+        value: rightValue
       }
     };
   }
@@ -2319,13 +2440,6 @@ var init$7 = function init(publicName, metric, queryEngineConfig) {
   };
 };
 
-function combineForCustomMetricFilters(filters, customFilters) {
-  if (customFilters && isAvailable(customFilters)) {
-    return addAndFilters(filters != null ? filters : [], customFilters);
-  }
-  return filters != null ? filters : [];
-}
-
 var PropertyType = /*#__PURE__*/function (PropertyType) {
   PropertyType["Operator"] = "operator";
   PropertyType["IfLogic"] = "ifLogic";
@@ -2359,21 +2473,13 @@ var build$8 = function build(measureAttribute, customField, dataSet, queryEngine
   return buildOperator(customField.metric, dataSet, params, measureAttribute, false);
 };
 var buildIfLogic = function buildIfLogic(ifLogic, dataSet, queryEngineConfig, params, measureAttribute) {
-  var alwaysTrueFilter = [[{
-    value: 1,
-    op: '=',
-    field: {
-      type: 'number',
-      value: 1
-    }
-  }]];
   var cases = function () {
     var thenCases = ifLogic.cases.map(function (c) {
-      var _params$filterConfig$, _params$filterConfig;
-      var customMetricFilter = combineForCustomMetricFilters((_params$filterConfig$ = params == null || (_params$filterConfig = params.filterConfig) == null ? void 0 : _params$filterConfig.viewFilters) != null ? _params$filterConfig$ : [], c.filter);
+      var customMetricFilter = convertArrayFilterStructureToQueryFilter(c.filter, params.variables);
+      var completeFilters = buildQueryCustomMetrics(customMetricFilter, dataSet, queryEngineConfig, params);
       return {
         returns: buildMetric(c.returns, dataSet, params, measureAttribute),
-        filter: filterAttributeToQueryFilter(customMetricFilter, queryEngineConfig, dataSet, params)
+        filter: completeFilters
       };
     });
     if (!ifLogic["else"]) return [].concat(thenCases, [{
@@ -2386,7 +2492,12 @@ var buildIfLogic = function buildIfLogic(ifLogic, dataSet, queryEngineConfig, pa
       returns: buildMetric(ifLogic["else"], dataSet, params, measureAttribute),
       filter: alwaysTrueFilter // Do not remove
     };
-    return [].concat(thenCases, [elseCase]);
+    return [].concat(thenCases, [elseCase, {
+      returns: {
+        type: 'null'
+      },
+      filter: alwaysTrueFilter // Do not remove
+    }]);
   }();
   if (!(measureAttribute != null && measureAttribute["function"]) || measureAttribute["function"] === 'none') {
     throw new Error('measure needs to be defined for if logic');
@@ -2541,11 +2652,12 @@ var init$8 = function init(publicName, fieldId, roundToDecimalPlaces, queryEngin
     }, queryEngineConfig)
   };
 };
-var build$9 = function build(measureAttribute, customField) {
+var build$9 = function build(measureAttribute, customField, variables) {
+  var value = useValue(customField.fieldId, variables);
   var builtRoundedNumber = {
     type: 'field',
     "function": "round_to_" + customField.roundToDecimalPlaces + "_dp",
-    value: customField.fieldId
+    value: value
   };
   if (measureAttribute["function"] == 'none') return builtRoundedNumber;
   return {
@@ -2606,19 +2718,19 @@ var toQueryMeasure = function toQueryMeasure(measureAttribute, customField, quer
     return build$6(measureAttribute, customField, queryEngineConfig, dataSet, params);
   }
   if (isAggregateMathField(customField)) {
-    return build$4(customField);
+    return build$4(customField, params.variables);
   }
   if (isSimpleMathField(customField)) {
     return build$3(measureAttribute, customField, dataSet, params);
   }
   if (isRoundedNumberField(customField)) {
-    return build$9(measureAttribute, customField);
+    return build$9(measureAttribute, customField, params.variables);
   }
   if (isConditional(customField)) {
     return build$5(customField, queryEngineConfig, dataSet, params);
   }
   if (isDateCalculation(customField)) {
-    return build$7(measureAttribute, customField);
+    return build$7(measureAttribute, customField, params.variables);
   }
   if (isCustomBuildMetric(customField)) {
     return build$8(measureAttribute, customField, dataSet, queryEngineConfig, params);
@@ -2933,13 +3045,44 @@ var dimensionSchema = function dimensionSchema(supportedTimeTruncFunctions, attr
   }
   return Joi.array().items(buildDimensionJoi(Joi.string().description('The ID of the field from the data set to reference.'), true)).description('Fields to group the data by');
 };
-var filterSchema = function filterSchema(queryEngineConfig) {
+var queryFilterSchema = function queryFilterSchema(queryEngineConfig, maxDepth) {
   var _Joi$string3, _Joi$string4;
+  if (maxDepth === void 0) {
+    maxDepth = 10;
+  }
+  var whereFilterSchema = Joi.object({
+    field: Joi.object({
+      type: Joi.string().valid('field').required(),
+      value: Joi.string().required().description('The ID of the field from the data set to reference.'),
+      "function": (_Joi$string3 = Joi.string()).valid.apply(_Joi$string3, Object.keys(queryEngineConfig.supportedAggregates).concat(Object.keys(queryEngineConfig.supportedTimeTruncFunctions), ['none'])).description('Which function should be applied to the field?')
+    }),
+    op: (_Joi$string4 = Joi.string()).valid.apply(_Joi$string4, Object.keys(queryEngineConfig.supportedOperators)).required(),
+    value: Joi.alternatives()["try"](joiDate, Joi.string().allow(null), Joi.number(), Joi["boolean"](), Joi.array().items(Joi.string(), Joi.number(), Joi.allow(null)), relativeSchema).required()
+  });
+  var _buildRecursiveSchema = function buildRecursiveSchema(depth) {
+    if (depth <= 0) {
+      return Joi.object({
+        type: Joi.string().valid('where').required(),
+        value: whereFilterSchema.required()
+      });
+    }
+    return Joi.alternatives()["try"](Joi.object({
+      type: Joi.string().valid('where').required(),
+      value: whereFilterSchema.required()
+    }), Joi.object({
+      type: Joi.string().valid('andWhere', 'orWhere').required(),
+      value: Joi.array().items(_buildRecursiveSchema(depth - 1)).min(1).required().description('Array of nested filters')
+    }));
+  };
+  return _buildRecursiveSchema(maxDepth);
+};
+var filterSchema = function filterSchema(queryEngineConfig) {
+  var _Joi$string5, _Joi$string6;
   return Joi.object({
     field: Joi.string().required().description('The ID of the field from the data set to reference.'),
-    op: (_Joi$string3 = Joi.string()).valid.apply(_Joi$string3, Object.keys(queryEngineConfig.supportedOperators)).required(),
+    op: (_Joi$string5 = Joi.string()).valid.apply(_Joi$string5, Object.keys(queryEngineConfig.supportedOperators)).required(),
     value: Joi.alternatives()["try"](joiDate, Joi.string().allow(null), Joi.number(), Joi["boolean"](), Joi.array().items(Joi.string(), Joi.number(), Joi.allow(null)), relativeSchema).required(),
-    "function": (_Joi$string4 = Joi.string()).valid.apply(_Joi$string4, Object.keys(queryEngineConfig.supportedAggregates).concat(Object.keys(queryEngineConfig.supportedTimeTruncFunctions), ['none'])).description('Which function should be applied to the field?')
+    "function": (_Joi$string6 = Joi.string()).valid.apply(_Joi$string6, Object.keys(queryEngineConfig.supportedAggregates).concat(Object.keys(queryEngineConfig.supportedTimeTruncFunctions), ['none'])).description('Which function should be applied to the field?')
   });
 };
 var queryAttributesFilter = function queryAttributesFilter(queryEngineConfig) {
@@ -2949,8 +3092,8 @@ var queryAttributesLimit = function queryAttributesLimit() {
   return Joi.number().description('Limit the number of results returned after the query has been ran.');
 };
 var baseAttributesSchema = function baseAttributesSchema(attributeSchemaOptions) {
-  var _Joi$string5;
-  var dataSetIdSchema = attributeSchemaOptions != null && attributeSchemaOptions.restrictDataSetIds ? (_Joi$string5 = Joi.string()).valid.apply(_Joi$string5, attributeSchemaOptions.restrictDataSetIds) : Joi.string();
+  var _Joi$string7;
+  var dataSetIdSchema = attributeSchemaOptions != null && attributeSchemaOptions.restrictDataSetIds ? (_Joi$string7 = Joi.string()).valid.apply(_Joi$string7, attributeSchemaOptions.restrictDataSetIds) : Joi.string();
   return {
     viewId: Joi.string().allow('').optional().description('__vizzly_hide_from_docs'),
     displayTitle: Joi.string().allow('').description('A title that explains what is being displayed.'),
@@ -2987,16 +3130,16 @@ var timeDimensionQuerySchema = function timeDimensionQuerySchema(queryEngineConf
 var lineCurveSchema = /*#__PURE__*/Joi.string().valid('natural', 'straight', 'step', 'stepBefore', 'stepAfter', 'dotted');
 var areaCurveSchema = /*#__PURE__*/Joi.string().valid('natural', 'straight', 'step');
 var protectedFieldsMeasure = function protectedFieldsMeasure(queryEngineConfig) {
-  var _Joi$string6;
+  var _Joi$string8;
   return Joi.array().items(Joi.object({
-    "function": (_Joi$string6 = Joi.string()).valid.apply(_Joi$string6, Object.keys(queryEngineConfig.supportedAggregates).concat(Object.keys(queryEngineConfig.supportedTimeTruncFunctions), ['none'])),
+    "function": (_Joi$string8 = Joi.string()).valid.apply(_Joi$string8, Object.keys(queryEngineConfig.supportedAggregates).concat(Object.keys(queryEngineConfig.supportedTimeTruncFunctions), ['none'])),
     field: Joi.string().required().description('The ID of the field from the data set to reference.')
   }));
 };
 var protectedFieldsDimension = function protectedFieldsDimension(queryEngineConfig) {
-  var _Joi$string7;
+  var _Joi$string9;
   return Joi.array().items(Joi.object({
-    "function": (_Joi$string7 = Joi.string()).valid.apply(_Joi$string7, Object.keys(queryEngineConfig.supportedAggregates).concat(Object.keys(queryEngineConfig.supportedTimeTruncFunctions), ['none'])),
+    "function": (_Joi$string9 = Joi.string()).valid.apply(_Joi$string9, Object.keys(queryEngineConfig.supportedAggregates).concat(Object.keys(queryEngineConfig.supportedTimeTruncFunctions), ['none'])),
     truncate: Joi.string(),
     field: Joi.string().required().description('The ID of the field from the data set to reference.'),
     bucketFill: Joi["boolean"]().optional(),
@@ -15127,8 +15270,7 @@ var fieldSchema = /*#__PURE__*/Joi.object({
   dataSetId: /*#__PURE__*/Joi.string().required()
 });
 var optionsFiltersSchema = function optionsFiltersSchema(queryEngineConfig) {
-  var innerArraySchema = Joi.array().items(filterSchema(queryEngineConfig));
-  return Joi.object().pattern(Joi.string(), Joi.array().items(innerArraySchema).optional());
+  return Joi.object().pattern(Joi.string(), queryFilterSchema(queryEngineConfig));
 };
 var sharedAdditionalFilterSchema = function sharedAdditionalFilterSchema(queryEngineConfig) {
   return {
@@ -26400,7 +26542,9 @@ var buildFromQueryAttributes = function buildFromQueryAttributes(dataSet, measur
   var measure = [];
   var group = [];
   var order = [];
-  var filters = filterAttributeToQueryFilter(filterAttr, queryEngineConfig, dataSet, params);
+  var queryFilterConfig = combineFiltersFromFilterConfig(params.filterConfig, dataSet, params.timeRangeOptions, params.variables);
+  var queryFiltersFromAttributes = convertArrayFilterStructureToQueryFilter(filterAttr, params.variables);
+  var filters = combineQueryFilters(queryFilterConfig, queryFiltersFromAttributes);
   if (timeDimensionAttr) {
     // Add the measure for the time field.
     var addedAt = undefined;
@@ -40255,7 +40399,8 @@ var _GlobalFiltersView = /*#__PURE__*/withCustomRenderGuard(function (props) {
     dateFilterOptions = _useDashboardBehaviou.dateFilterOptions,
     featureToggles = _useDashboardBehaviou.featureToggles,
     cascadeFilterSelection = _useDashboardBehaviou.cascadeFilterSelection,
-    scope = _useDashboardBehaviou.scope;
+    scope = _useDashboardBehaviou.scope,
+    variables = _useDashboardBehaviou.variables;
   return jsxRuntime.jsxs(Flex, {
     gap: "0.5rem",
     "data-component": "filters",
@@ -40263,12 +40408,13 @@ var _GlobalFiltersView = /*#__PURE__*/withCustomRenderGuard(function (props) {
     wrap: true,
     children: [props.globalFilters.length > 0 && jsxRuntime.jsx(React.Fragment, {
       children: [].concat(props.globalFilters).map(function (globalFilter, globalFilterIndex) {
+        var _variables$variables;
         return jsxRuntime.jsx(AdditionalFilter, {
           shouldAlwaysHaveValue: globalFilter.requiresValue,
           dataSets: dashboard.dataSets,
           dateFilterOptions: dateFilterOptions,
           filter: _extends({}, globalFilter, {
-            optionsFilters: getCascadeOptionsFilters(props == null ? void 0 : props.globalFilters, dashboard.dataSets, dateFilterOptions, cascadeFilterSelection)
+            optionsFilters: getCascadeOptionsFilters(props == null ? void 0 : props.globalFilters, dashboard.dataSets, dateFilterOptions, (_variables$variables = variables == null ? void 0 : variables.variables) != null ? _variables$variables : {}, cascadeFilterSelection)
           }),
           filterIndex: globalFilterIndex,
           onChange: function onChange(newFilter) {
@@ -74150,7 +74296,9 @@ var toQueries$1 = function toQueries$1(additionalFilter, dataSets, queryEngineCo
     if (!dataSet) throw 'Data set not found for additional filter query';
     var dataSetField = findField(dataSet, field.fieldId);
     if (dataSetField.dataType == 'string[]') {
-      var queryFilter = filterAttributeToQueryFilter(getOptionsFilters(additionalFilter, field), queryEngineConfig, dataSet, params);
+      var optionsFilter = getOptionsFilters(additionalFilter, field);
+      var queryFilterConfig = combineFiltersFromFilterConfig(params.filterConfig, dataSet, params.timeRangeOptions, params.variables);
+      var queryFilter = combineQueryFilters(queryFilterConfig, optionsFilter);
       var _QueryLogic$buildUniq = buildUniqueArrayValuesPreparedQuery(field.dataSetId, dataSetField, queryFilter),
         query = _QueryLogic$buildUniq.query,
         resultFields = _QueryLogic$buildUniq.resultFields;
@@ -74159,8 +74307,17 @@ var toQueries$1 = function toQueries$1(additionalFilter, dataSets, queryEngineCo
         resultFields: [resultFields]
       };
     } else {
-      var filterQuery = buildFilterQuery(dataSet, field.fieldId, getOptionsFilters(additionalFilter, field), getOptionsOrders(dataSetField));
-      return toQueries(dataSets, [filterQuery], queryEngineConfig, params);
+      var optionFilters = getOptionsFilters(additionalFilter, field);
+      var filterQuery = buildFilterQuery(dataSet, field.fieldId, [], getOptionsOrders(dataSetField));
+      var queryWithoutFilters = toQueries(dataSets, [filterQuery], queryEngineConfig, params);
+      return {
+        resultFields: queryWithoutFilters.resultFields,
+        queries: queryWithoutFilters.queries.map(function (q) {
+          return _extends({}, q, {
+            filter: optionFilters
+          });
+        })
+      };
     }
   });
   return {
@@ -74173,21 +74330,45 @@ var toQueries$1 = function toQueries$1(additionalFilter, dataSets, queryEngineCo
   };
 };
 function getOptionsFilters(additionalFilter, field) {
-  if (!additionalFilter.optionsFilters) {
-    return [];
+  var optionsFilters = additionalFilter.optionsFilters ? additionalFilter.optionsFilters[field.dataSetId] : undefined;
+  if (!optionsFilters) {
+    return {
+      type: 'andWhere',
+      value: []
+    };
   }
-  if (!(field.dataSetId in additionalFilter.optionsFilters)) {
-    return [];
+  var filteredQuery = filterOutFieldId(optionsFilters, field.fieldId);
+  return filteredQuery || {
+    type: 'andWhere',
+    value: []
+  };
+}
+function filterOutFieldId(filter, fieldIdToExclude) {
+  if (filter.type === 'where') {
+    var field = getFieldFromFilter(filter);
+    if (field && field.value === fieldIdToExclude) {
+      return null;
+    }
+    return filter;
   }
-  var optionsFilters = additionalFilter.optionsFilters[field.dataSetId];
-  var orFilter = optionsFilters.map(function (filter) {
-    return filter.filter(function (f) {
-      return f.field !== field.fieldId;
+  if (filter.type === 'andWhere' || filter.type === 'orWhere') {
+    var filteredValues = filter.value.map(function (f) {
+      return filterOutFieldId(f, fieldIdToExclude);
+    }).filter(function (f) {
+      return f !== null;
     });
-  });
-  return orFilter.filter(function (f) {
-    return f.length > 0;
-  });
+    if (filteredValues.length === 0) {
+      return null;
+    }
+    if (filteredValues.length === 1 && filteredValues[0].type === filter.type) {
+      return filteredValues[0];
+    }
+    return {
+      type: filter.type,
+      value: filteredValues
+    };
+  }
+  return filter;
 }
 function getOptionsOrders(dataSetField) {
   if ((dataSetField == null ? void 0 : dataSetField.dataType) === 'string' || (dataSetField == null ? void 0 : dataSetField.dataType) === 'number') {
@@ -74473,11 +74654,7 @@ var buildVizzlyQuery = function buildVizzlyQuery(thing, queryEngineConfig, param
       query = _QueryLogic$buildPreA.query,
       rF = _QueryLogic$buildPreA.resultFields;
     var underlyingDataSet = find(params.dataSets, underlyingDataSetId);
-    var filter = filterAttributeToQueryFilter([], queryEngineConfig, underlyingDataSet, _extends({}, params, {
-      filterConfig: _extends({}, params.filterConfig, {
-        viewFilters: undefined
-      })
-    }));
+    var filter = combineFiltersFromFilterConfig(params.filterConfig, underlyingDataSet, params.timeRangeOptions, params.variables);
     queriesToSend = [_extends({}, query, {
       filter: (_filter = {}, _filter[underlyingDataSet.id] = filter, _filter)
     })];
@@ -74530,6 +74707,14 @@ var buildVizzlyQuery = function buildVizzlyQuery(thing, queryEngineConfig, param
       });
     });
   }
+  queriesToSend = queriesToSend.map(function (q) {
+    if (q.type === 'query') {
+      return _extends({}, q, {
+        filter: buildQueryCustomMetrics(q.filter, find(params.dataSets, q.dataSetId), queryEngineConfig, params)
+      });
+    }
+    return q;
+  });
   return {
     queries: queriesToSend,
     resultFields: resultFields