Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.
TypeScript analyticsanalytics-dashboardclickhouseelixirgoogle-analyticsmarketingopen-source-analyticsphoenixplausible-analyticspostgresqlprivacyprivacy-friendlyself-hostedsimple-analyticsstatisticstailwindcssweb-analyticswebsite-analyticswebsite-statswebsite-tracking
Multiple filters on the frontend (#4174)
Karl-Aksel Puulmanne1f0002d2ebc
diff --git a/assets/js/dashboard/stats/modals/filter-modal-group.js b/assets/js/dashboard/stats/modals/filter-modal-group.jsindex b8eee128e4..8cfea5ebbb 100644--- a/assets/js/dashboard/stats/modals/filter-modal-group.js+++ b/assets/js/dashboard/stats/modals/filter-modal-group.js@@ -17,18 +17,17 @@ export default function FilterModalGroup({() => Object.entries(filterState).filter(([_, filter]) => getFilterGroup(filter) == filterGroup).map(([id, filter]) => ({ id, filter })),[filterGroup, filterState])-const disabledOptions = useMemo(() => (filterGroup == 'props') ? rows.map(({ filter }) => ({ value: getPropertyKeyFromFilterKey(filter[1]) })) : null,[filterGroup, rows])- const showAddRow = filterGroup == 'props'+ const showAddRow = site.flags.multiple_filters ? !['goal', 'hostname'].includes(filterGroup) : filterGroup == 'props'const showTitle = filterGroup != 'props'return (<>- <div className="mt-4">+ <div className="mt-6">{showTitle && (<div className="text-sm font-medium text-gray-700 dark:text-gray-300">{formattedFilters[filterGroup]}</div>)}{rows.map(({ id, filter }) =>filterGroup === 'props' ? (@@ -55,7 +54,7 @@ export default function FilterModalGroup({)}</div>{showAddRow && (- <div className="mt-6">+ <div className="mt-2"><a className="underline text-indigo-500 text-sm cursor-pointer" onClick={() => onAddRow(filterGroup)}>+ Add another</a>diff --git a/assets/js/dashboard/util/filters.js b/assets/js/dashboard/util/filters.jsindex 27367e260d..d41693db70 100644--- a/assets/js/dashboard/util/filters.js+++ b/assets/js/dashboard/util/filters.js@@ -34,6 +34,12 @@ export const OPERATION_PREFIX = {[FILTER_OPERATIONS.is]: ''};+export const BACKEND_OPERATION = {+ [FILTER_OPERATIONS.is]: 'is',+ [FILTER_OPERATIONS.isNot]: 'is_not',+ [FILTER_OPERATIONS.contains]: 'matches'+}+export function supportsIsNot(filterName) {return !['goal', 'prop_key'].includes(filterName)}@@ -53,17 +59,6 @@ try {const ESCAPED_PIPE = '\\|'-function escapeFilterValue(value) {- return value.replaceAll(NON_ESCAPED_PIPE_REGEX, ESCAPED_PIPE)-}--function toFilterQuery(type, clauses) {- const prefix = OPERATION_PREFIX[type];- const result = clauses.map(clause => escapeFilterValue(clause.toString().trim())).join('|')- return prefix + result;-}--export function getLabel(labels, filterKey, value) {if (['country', 'region', 'city'].includes(filterKey)) {return labels[value]@@ -141,19 +136,21 @@ export function cleanLabels(filters, labels, mergedFilterKey, mergedLabels) {return result}+const EVENT_FILTER_KEYS = new Set(["name", "page", "goal", "hostname"])-// :TODO: New schema for filters in the BEexport function serializeApiFilters(filters) {- const cleaned = {}- filters.forEach(([operation, filterKey, clauses]) => {- if (filterKey.startsWith(EVENT_PROPS_PREFIX)) {- cleaned.props ||= {}- cleaned.props[getPropertyKeyFromFilterKey(filterKey)] = toFilterQuery(operation, clauses)- } else {- cleaned[filterKey] = toFilterQuery(operation, clauses)+ const apiFilters = filters.map(([operation, filterKey, clauses]) => {+ let apiFilterKey = `visit:${filterKey}`+ if (filterKey.startsWith(EVENT_PROPS_PREFIX) || EVENT_FILTER_KEYS.has(filterKey)) {+ apiFilterKey = `event:${filterKey}`}+ if (operation == FILTER_OPERATIONS.contains) {+ clauses = clauses.map((value) => value.includes('*') ? value : `**${value}**`)+ }+ return [BACKEND_OPERATION[operation], apiFilterKey, clauses]})- return JSON.stringify(cleaned)++ return JSON.stringify(apiFilters)}export function fetchSuggestions(apiPath, query, input, additionalFilter) {diff --git a/extra/lib/plausible/stats/goal/revenue.ex b/extra/lib/plausible/stats/goal/revenue.exindex 8c4115c0aa..d531b5d638 100644--- a/extra/lib/plausible/stats/goal/revenue.ex+++ b/extra/lib/plausible/stats/goal/revenue.ex@@ -40,8 +40,7 @@ defmodule Plausible.Stats.Goal.Revenue dodef get_revenue_tracking_currency(site, query, metrics) dogoal_filters =case Query.get_filter(query, "event:goal") do- [:is, "event:goal", {_, goal_name}] -> [goal_name]- [:member, "event:goal", list] -> Enum.map(list, fn {_, goal_name} -> goal_name end)+ [:is, "event:goal", list] -> Enum.map(list, fn {_, goal_name} -> goal_name end)_ -> []enddiff --git a/lib/plausible/google/search_console/filters.ex b/lib/plausible/google/search_console/filters.exindex 484ed84390..ee9bc21578 100644--- a/lib/plausible/google/search_console/filters.ex+++ b/lib/plausible/google/search_console/filters.ex@@ -23,23 +23,14 @@ defmodule Plausible.Google.SearchConsole.Filters dotransform_filter(property, [op, "visit:entry_page" | rest])end- defp transform_filter(property, [:is, "visit:entry_page", page]) when is_binary(page) do- %{dimension: "page", expression: property_url(property, page)}- end-- defp transform_filter(property, [:member, "visit:entry_page", pages]) when is_list(pages) do+ defp transform_filter(property, [:is, "visit:entry_page", pages]) when is_list(pages) doexpression =Enum.map_join(pages, "|", fn page -> property_url(property, Regex.escape(page)) end)%{dimension: "page", operator: "includingRegex", expression: expression}end- defp transform_filter(property, [:matches, "visit:entry_page", page]) when is_binary(page) do- page = page_regex(property_url(property, page))- %{dimension: "page", operator: "includingRegex", expression: page}- end-- defp transform_filter(property, [:matches_member, "visit:entry_page", pages])+ defp transform_filter(property, [:matches, "visit:entry_page", pages])when is_list(pages) doexpression =Enum.map_join(pages, "|", fn page -> page_regex(property_url(property, page)) end)@@ -47,20 +38,12 @@ defmodule Plausible.Google.SearchConsole.Filters do%{dimension: "page", operator: "includingRegex", expression: expression}end- defp transform_filter(_property, [:is, "visit:screen", device]) when is_binary(device) do- %{dimension: "device", expression: search_console_device(device)}- end-- defp transform_filter(_property, [:member, "visit:screen", devices]) when is_list(devices) do- expression = devices |> Enum.join("|")+ defp transform_filter(_property, [:is, "visit:screen", devices]) when is_list(devices) do+ expression = Enum.map_join(devices, "|", &search_console_device/1)%{dimension: "device", operator: "includingRegex", expression: expression}end- defp transform_filter(_property, [:is, "visit:country", country]) when is_binary(country) do- %{dimension: "country", expression: search_console_country(country)}- end-- defp transform_filter(_property, [:member, "visit:country", countries])+ defp transform_filter(_property, [:is, "visit:country", countries])when is_list(countries) doexpression = Enum.map_join(countries, "|", &search_console_country/1)%{dimension: "country", operator: "includingRegex", expression: expression}diff --git a/lib/plausible/stats/base.ex b/lib/plausible/stats/base.exindex 85ffa7cd4c..a449d0fd30 100644--- a/lib/plausible/stats/base.ex+++ b/lib/plausible/stats/base.ex@@ -320,7 +320,7 @@ defmodule Plausible.Stats.Base dodef add_percentage_metric(q, site, query, metrics) doif :percentage in metrics do- total_query = Query.set_property(query, nil)+ total_query = Query.set_dimensions(query, [])q|> select_merge(@@ -348,7 +348,7 @@ defmodule Plausible.Stats.Base dototal_query =query|> Query.remove_filters(["event:goal", "event:props"])- |> Query.set_property(nil)+ |> Query.set_dimensions([])# :TRICKY: Subquery is used due to event:goal breakdown above doing an UNION ALLsubquery(q)diff --git a/lib/plausible/stats/breakdown.ex b/lib/plausible/stats/breakdown.exindex 23db74a9e0..6f3799e831 100644--- a/lib/plausible/stats/breakdown.ex+++ b/lib/plausible/stats/breakdown.ex@@ -27,7 +27,7 @@ defmodule Plausible.Stats.Breakdown dodef breakdown(site,- %Query{property: "event:goal"} = query,+ %Query{dimensions: ["event:goal"]} = query,metrics,pagination,opts@@ -39,8 +39,8 @@ defmodule Plausible.Stats.Breakdown doevent_query =query- |> Query.put_filter([:member, "event:name", events])- |> Query.set_property("event:name")+ |> Query.put_filter([:is, "event:name", events])+ |> Query.set_dimensions(["event:name"])if !Keyword.get(opts, :skip_tracing), do: Query.trace(query, metrics)@@ -73,7 +73,7 @@ defmodule Plausible.Stats.Breakdown dopage_q =if Enum.any?(pageview_goals) do- page_query = Query.set_property(query, "event:page")+ page_query = Query.set_dimensions(query, ["event:page"])page_exprs = Enum.map(pageview_goals, & &1.page_path)page_regexes = Enum.map(page_exprs, &page_regex/1)@@ -134,7 +134,7 @@ defmodule Plausible.Stats.Breakdown dodef breakdown(site,- %Query{property: "event:props:" <> custom_prop} = query,+ %Query{dimensions: ["event:props:" <> custom_prop]} = query,metrics,pagination,opts@@ -157,7 +157,7 @@ defmodule Plausible.Stats.Breakdown do|> Enum.map(&cast_revenue_metrics_to_money(&1, currency))end- def breakdown(site, %Query{property: "event:page"} = query, metrics, pagination, opts) do+ def breakdown(site, %Query{dimensions: ["event:page"]} = query, metrics, pagination, opts) doevent_metrics =metrics|> Util.maybe_add_visitors_metric()@@ -182,8 +182,8 @@ defmodule Plausible.Stats.Breakdown dopages ->query|> Query.remove_filters(["event:page"])- |> Query.put_filter([:member, "visit:entry_page", Enum.map(pages, & &1[:page])])- |> Query.set_property("visit:entry_page")+ |> Query.put_filter([:is, "visit:entry_page", Enum.map(pages, & &1[:page])])+ |> Query.set_dimensions(["visit:entry_page"])endif Enum.any?(event_metrics) && Enum.empty?(event_result) do@@ -208,7 +208,7 @@ defmodule Plausible.Stats.Breakdown doendend- def breakdown(site, %Query{property: "event:name"} = query, metrics, pagination, opts) do+ def breakdown(site, %Query{dimensions: ["event:name"]} = query, metrics, pagination, opts) doif !Keyword.get(opts, :skip_tracing), do: Query.trace(query, metrics)breakdown_events(site, query, metrics)@@ -234,7 +234,7 @@ defmodule Plausible.Stats.Breakdown doendend- defp maybe_update_breakdown_filters(%Query{property: visit_entry_prop} = query)+ defp maybe_update_breakdown_filters(%Query{dimensions: [visit_entry_prop]} = query)when visit_entry_prop in ["visit:source","visit:entry_page",@@ -249,7 +249,7 @@ defmodule Plausible.Stats.Breakdown doupdate_hostname_filter_prop(query, "visit:entry_page_hostname")end- defp maybe_update_breakdown_filters(%Query{property: "visit:exit_page"} = query) do+ defp maybe_update_breakdown_filters(%Query{dimensions: ["visit:exit_page"]} = query) doupdate_hostname_filter_prop(query, "visit:exit_page_hostname")end@@ -271,13 +271,13 @@ defmodule Plausible.Stats.Breakdown do# Backwards compatibilitydefp breakdown_table(%Query{experimental_reduced_joins?: false}, _), do: :session- defp breakdown_table(%Query{property: "visit:entry_page"}, _metrics), do: :session- defp breakdown_table(%Query{property: "visit:entry_page_hostname"}, _metrics), do: :session- defp breakdown_table(%Query{property: "visit:exit_page"}, _metrics), do: :session- defp breakdown_table(%Query{property: "visit:exit_page_hostname"}, _metrics), do: :session+ defp breakdown_table(%Query{dimensions: ["visit:entry_page"]}, _metrics), do: :session+ defp breakdown_table(%Query{dimensions: ["visit:entry_page_hostname"]}, _metrics), do: :session+ defp breakdown_table(%Query{dimensions: ["visit:exit_page"]}, _metrics), do: :session+ defp breakdown_table(%Query{dimensions: ["visit:exit_page_hostname"]}, _metrics), do: :session- defp breakdown_table(%Query{property: property} = query, metrics) do- {_, session_metrics, _} = TableDecider.partition_metrics(metrics, query, property)+ defp breakdown_table(%Query{dimensions: [dimension]} = query, metrics) do+ {_, session_metrics, _} = TableDecider.partition_metrics(metrics, query, dimension)if not Enum.empty?(session_metrics) do:session@@ -304,23 +304,23 @@ defmodule Plausible.Stats.Breakdown do|> sort_results(metrics)end- defp breakdown_sessions(site, %Query{property: property} = query, metrics) do+ defp breakdown_sessions(site, %Query{dimensions: [dimension]} = query, metrics) dofrom(s in query_sessions(site, query),order_by: [desc: fragment("uniq(?)", s.user_id)],select: ^select_session_metrics(metrics, query))|> filter_converted_sessions(site, query)- |> do_group_by(property)+ |> do_group_by(dimension)|> merge_imported(site, query, metrics)|> add_percentage_metric(site, query, metrics)end- defp breakdown_events(site, %Query{property: property} = query, metrics) do+ defp breakdown_events(site, %Query{dimensions: [dimension]} = query, metrics) dofrom(e in base_event_query(site, query),order_by: [desc: fragment("uniq(?)", e.user_id)],select: %{})- |> do_group_by(property)+ |> do_group_by(dimension)|> select_merge(^select_event_metrics(metrics))|> merge_imported(site, query, metrics)|> add_percentage_metric(site, query, metrics)@@ -718,7 +718,7 @@ defmodule Plausible.Stats.Breakdown doq,breakdown_fn,site,- %Query{property: property} = query,+ %Query{dimensions: [dimension]} = query,metrics) doif :conversion_rate in metrics do@@ -730,7 +730,7 @@ defmodule Plausible.Stats.Breakdown dofrom(e in subquery(q),left_join: c in subquery(breakdown_total_visitors_q),- on: ^on_matches_group_by(group_by_field_names(property)),+ on: ^on_matches_group_by(group_by_field_names(dimension)),select_merge: %{total_visitors: c.visitors,conversion_rate:@@ -742,7 +742,7 @@ defmodule Plausible.Stats.Breakdown do)},order_by: [desc: e.visitors],- order_by: ^outer_order_by(group_by_field_names(property))+ order_by: ^outer_order_by(group_by_field_names(dimension)))elseqdiff --git a/lib/plausible/stats/email_report.ex b/lib/plausible/stats/email_report.exindex 675597731b..1dc26465bb 100644--- a/lib/plausible/stats/email_report.ex+++ b/lib/plausible/stats/email_report.ex@@ -40,7 +40,7 @@ defmodule Plausible.Stats.EmailReport doenddefp put_top_5_pages(stats, site, query) do- query = Query.set_property(query, "event:page")+ query = Query.set_dimensions(query, ["event:page"])pages = Stats.breakdown(site, query, [:visitors], {5, 1})Map.put(stats, :pages, pages)end@@ -48,8 +48,8 @@ defmodule Plausible.Stats.EmailReport dodefp put_top_5_sources(stats, site, query) doquery =query- |> Query.put_filter([:is_not, "visit:source", "Direct / None"])- |> Query.set_property("visit:source")+ |> Query.put_filter([:is_not, "visit:source", ["Direct / None"]])+ |> Query.set_dimensions(["visit:source"])sources = Stats.breakdown(site, query, [:visitors], {5, 1})diff --git a/lib/plausible/stats/filters/filters.ex b/lib/plausible/stats/filters/filters.exindex 3775e73435..b6760965ed 100644--- a/lib/plausible/stats/filters/filters.ex+++ b/lib/plausible/stats/filters/filters.ex@@ -3,7 +3,8 @@ defmodule Plausible.Stats.Filters doA module for parsing filters used in stat queries."""- alias Plausible.Stats.Filters.{DashboardFilterParser, StatsAPIFilterParser}+ alias Plausible.Stats.Filters.QueryParser+ alias Plausible.Stats.Filters.{LegacyDashboardFilterParser, StatsAPIFilterParser}@visit_props [:source,@@ -47,32 +48,39 @@ defmodule Plausible.Stats.Filters doDepending on the format and type of the `filters` argument, returns:- * a decoded map, when `filters` is encoded JSON- * a parsed filter map, when `filters` is a filter expression string- * the same map, when `filters` is a map+ * a decoded list, when `filters` is encoded JSON+ * a parsed filter list, when `filters` is a filter expression string+ * the same list, when `filters` is a map- Returns an empty map when argument type is unexpected (e.g. `nil`).+ Returns an empty list when argument type is unexpected (e.g. `nil`).### Examples:iex> Filters.parse("{\\"page\\":\\"/blog/**\\"}")- [[:matches, "event:page", "/blog/**"]]+ [[:matches, "event:page", ["/blog/**"]]]iex> Filters.parse("visit:browser!=Chrome")- [[:is_not, "visit:browser", "Chrome"]]+ [[:is_not, "visit:browser", ["Chrome"]]]iex> Filters.parse(nil)[]"""def parse(filters) when is_binary(filters) docase Jason.decode(filters) do- {:ok, filters} when is_map(filters) -> DashboardFilterParser.parse_and_prefix(filters)+ {:ok, filters} when is_map(filters) or is_list(filters) -> parse(filters){:ok, _} -> []{:error, err} -> StatsAPIFilterParser.parse_filter_expression(err.data)endend- def parse(filters) when is_map(filters), do: DashboardFilterParser.parse_and_prefix(filters)+ def parse(filters) when is_map(filters),+ do: LegacyDashboardFilterParser.parse_and_prefix(filters)++ def parse(filters) when is_list(filters) do+ {:ok, parsed_filters} = QueryParser.parse_filters(filters)+ parsed_filters+ end+def parse(_), do: []def without_prefix(property) dodiff --git a/lib/plausible/stats/filters/dashboard_filter_parser.ex b/lib/plausible/stats/filters/legacy_dashboard_filter_parser.exsimilarity index 82%rename from lib/plausible/stats/filters/dashboard_filter_parser.exrename to lib/plausible/stats/filters/legacy_dashboard_filter_parser.exindex 926642eac4..67e8c8cd0f 100644--- a/lib/plausible/stats/filters/dashboard_filter_parser.ex+++ b/lib/plausible/stats/filters/legacy_dashboard_filter_parser.ex@@ -1,4 +1,4 @@-defmodule Plausible.Stats.Filters.DashboardFilterParser do+defmodule Plausible.Stats.Filters.LegacyDashboardFilterParser do@moduledoc falseimport Plausible.Stats.Filters.Utils@@ -36,40 +36,40 @@ defmodule Plausible.Stats.Filters.DashboardFilterParser docond dois_negated && is_wildcard && is_list ->- [:not_matches_member, key, val]+ [:does_not_match, key, val]is_negated && is_contains && is_list ->- [:not_matches_member, key, Enum.map(val, &"**#{&1}**")]+ [:does_not_match, key, Enum.map(val, &"**#{&1}**")]is_wildcard && is_list ->- [:matches_member, key, val]+ [:matches, key, val]is_negated && is_wildcard ->- [:does_not_match, key, val]+ [:does_not_match, key, [val]]is_negated && is_list ->- [:not_member, key, val]+ [:is_not, key, val]is_negated && is_contains ->- [:does_not_match, key, "**" <> val <> "**"]+ [:does_not_match, key, ["**" <> val <> "**"]]is_contains && is_list ->- [:matches_member, key, Enum.map(val, &"**#{&1}**")]+ [:matches, key, Enum.map(val, &"**#{&1}**")]is_negated ->- [:is_not, key, val]+ [:is_not, key, [val]]is_list ->- [:member, key, val]+ [:is, key, val]is_contains ->- [:matches, key, "**" <> val <> "**"]+ [:matches, key, ["**" <> val <> "**"]]is_wildcard ->- [:matches, key, val]+ [:matches, key, [val]]true ->- [:is, key, val]+ [:is, key, [val]]endenddiff --git a/lib/plausible/stats/filters/query_parser.ex b/lib/plausible/stats/filters/query_parser.exnew file mode 100644index 0000000000..d9825a2ccc--- /dev/null+++ b/lib/plausible/stats/filters/query_parser.ex@@ -0,0 +1,203 @@+defmodule Plausible.Stats.Filters.QueryParser do+ @moduledoc false++ alias Plausible.Stats.Filters++ def parse(params) when is_map(params) do+ with {:ok, metrics} <- parse_metrics(Map.get(params, "metrics", [])),+ {:ok, filters} <- parse_filters(Map.get(params, "filters", [])),+ {:ok, date_range} <- parse_date_range(Map.get(params, "date_range")),+ {:ok, dimensions} <- parse_dimensions(Map.get(params, "dimensions", [])),+ {:ok, order_by} <- parse_order_by(Map.get(params, "order_by")),+ query = %{+ metrics: metrics,+ filters: filters,+ date_range: date_range,+ dimensions: dimensions,+ order_by: order_by+ },+ :ok <- validate_order_by(query) do+ {:ok, query}+ end+ end++ defp parse_metrics([]), do: {:error, "No valid metrics passed"}++ defp parse_metrics(metrics) when is_list(metrics) do+ if length(metrics) == length(Enum.uniq(metrics)) do+ parse_list(metrics, &parse_metric/1)+ else+ {:error, "Metrics cannot be queried multiple times"}+ end+ end++ defp parse_metrics(_invalid_metrics), do: {:error, "Invalid metrics passed"}++ defp parse_metric("time_on_page"), do: {:ok, :time_on_page}+ defp parse_metric("conversion_rate"), do: {:ok, :conversion_rate}+ defp parse_metric("visitors"), do: {:ok, :visitors}+ defp parse_metric("pageviews"), do: {:ok, :pageviews}+ defp parse_metric("events"), do: {:ok, :events}+ defp parse_metric("visits"), do: {:ok, :visits}+ defp parse_metric("bounce_rate"), do: {:ok, :bounce_rate}+ defp parse_metric("visit_duration"), do: {:ok, :visit_duration}+ defp parse_metric(unknown_metric), do: {:error, "Unknown metric '#{inspect(unknown_metric)}'"}++ def parse_filters(filters) when is_list(filters) do+ parse_list(filters, &parse_filter/1)+ end++ def parse_filters(_invalid_metrics), do: {:error, "Invalid filters passed"}++ defp parse_filter(filter) do+ with {:ok, operator} <- parse_operator(filter),+ {:ok, filter_key} <- parse_filter_key(filter),+ {:ok, rest} <- parse_filter_rest(operator, filter) do+ {:ok, [operator, filter_key | rest]}+ end+ end++ defp parse_operator(["is" | _rest]), do: {:ok, :is}+ defp parse_operator(["is_not" | _rest]), do: {:ok, :is_not}+ defp parse_operator(["matches" | _rest]), do: {:ok, :matches}+ defp parse_operator(["does_not_match" | _rest]), do: {:ok, :does_not_match}+ defp parse_operator(filter), do: {:error, "Unknown operator for filter '#{inspect(filter)}'"}++ defp parse_filter_key([_operator, filter_key | _rest] = filter) do+ parse_filter_key_string(filter_key, "Invalid filter '#{inspect(filter)}")+ end++ defp parse_filter_key(filter), do: {:error, "Invalid filter '#{inspect(filter)}'"}++ defp parse_filter_rest(:is, filter), do: parse_clauses_list(filter)+ defp parse_filter_rest(:is_not, filter), do: parse_clauses_list(filter)+ defp parse_filter_rest(:matches, filter), do: parse_clauses_list(filter)+ defp parse_filter_rest(:does_not_match, filter), do: parse_clauses_list(filter)++ defp parse_clauses_list([_operation, filter_key, list] = filter) when is_list(list) do+ all_strings? = Enum.all?(list, &is_bitstring/1)++ cond do+ filter_key == "event:goal" && all_strings? -> {:ok, [Filters.Utils.wrap_goal_value(list)]}+ filter_key != "event:goal" && all_strings? -> {:ok, [list]}+ true -> {:error, "Invalid filter '#{inspect(filter)}'"}+ end+ end++ defp parse_clauses_list(filter), do: {:error, "Invalid filter '#{inspect(filter)}'"}++ defp parse_date_range("day"), do: {:ok, "day"}+ defp parse_date_range("7d"), do: {:ok, "7d"}+ defp parse_date_range("30d"), do: {:ok, "30d"}+ defp parse_date_range("month"), do: {:ok, "month"}+ defp parse_date_range("6mo"), do: {:ok, "6mo"}+ defp parse_date_range("12mo"), do: {:ok, "6mo"}+ defp parse_date_range("year"), do: {:ok, "year"}+ defp parse_date_range("all"), do: {:ok, "all"}++ defp parse_date_range([from_date_string, to_date_string])+ when is_bitstring(from_date_string) and is_bitstring(to_date_string) do+ with {:ok, from_date} <- Date.from_iso8601(from_date_string),+ {:ok, to_date} <- Date.from_iso8601(to_date_string) do+ {:ok, Date.range(from_date, to_date)}+ else+ _ -> {:error, "Invalid date_range '#{inspect([from_date_string, to_date_string])}'"}+ end+ end++ defp parse_date_range(unknown), do: {:error, "Invalid date range '#{inspect(unknown)}'"}++ defp parse_dimensions(dimensions) when is_list(dimensions) do+ if length(dimensions) == length(Enum.uniq(dimensions)) do+ parse_list(+ dimensions,+ &parse_filter_key_string(&1, "Invalid dimensions '#{inspect(dimensions)}'")+ )+ else+ {:error, "Some dimensions are listed multiple times"}+ end+ end++ defp parse_dimensions(dimensions), do: {:error, "Invalid dimensions '#{inspect(dimensions)}'"}++ def parse_order_by(order_by) when is_list(order_by) do+ parse_list(order_by, &parse_order_by_entry/1)+ end++ def parse_order_by(nil), do: {:ok, nil}+ def parse_order_by(order_by), do: {:error, "Invalid order_by '#{inspect(order_by)}'"}++ def parse_order_by_entry(entry) do+ with {:ok, metric_or_dimension} <- parse_metric_or_dimension(entry),+ {:ok, order_direction} <- parse_order_direction(entry) do+ {:ok, {metric_or_dimension, order_direction}}+ end+ end++ def parse_metric_or_dimension([metric_or_dimension, _] = entry) do+ case {parse_metric(metric_or_dimension), parse_filter_key_string(metric_or_dimension)} do+ {{:ok, metric}, _} -> {:ok, metric}+ {_, {:ok, dimension}} -> {:ok, dimension}+ _ -> {:error, "Invalid order_by entry '#{inspect(entry)}'"}+ end+ end++ def parse_order_direction([_, "asc"]), do: {:ok, :asc}+ def parse_order_direction([_, "desc"]), do: {:ok, :desc}+ def parse_order_direction(entry), do: {:error, "Invalid order_by entry '#{inspect(entry)}'"}++ defp parse_filter_key_string(filter_key, error_message \\ "") do+ case filter_key do+ "event:props:" <> _property_name ->+ {:ok, filter_key}++ "event:" <> key ->+ if key in Filters.event_props() do+ {:ok, filter_key}+ else+ {:error, error_message}+ end++ "visit:" <> key ->+ if key in Filters.visit_props() do+ {:ok, filter_key}+ else+ {:error, error_message}+ end++ _ ->+ {:error, error_message}+ end+ end++ def validate_order_by(query) do+ if query.order_by do+ valid_values = query.metrics ++ query.dimensions++ invalid_entry =+ Enum.find(query.order_by, fn {value, _direction} ->+ not Enum.member?(valid_values, value)+ end)++ case invalid_entry do+ nil ->+ :ok++ _ ->+ {:error,+ "Invalid order_by entry '#{inspect(invalid_entry)}'. Entry is not a queried metric or dimension"}+ end+ else+ :ok+ end+ end++ defp parse_list(list, parser_function) do+ Enum.reduce_while(list, {:ok, []}, fn value, {:ok, results} ->+ case parser_function.(value) do+ {:ok, result} -> {:cont, {:ok, results ++ [result]}}+ {:error, _} = error -> {:halt, error}+ end+ end)+ end+enddiff --git a/lib/plausible/stats/filters/stats_api_filter_parser.ex b/lib/plausible/stats/filters/stats_api_filter_parser.exindex fc58168993..5f02b6c8c6 100644--- a/lib/plausible/stats/filters/stats_api_filter_parser.ex+++ b/lib/plausible/stats/filters/stats_api_filter_parser.ex@@ -27,11 +27,11 @@ defmodule Plausible.Stats.Filters.StatsAPIFilterParser dofinal_value = remove_escape_chars(raw_value)cond do- is_wildcard? && is_negated? -> [:does_not_match, key, raw_value]- is_wildcard? -> [:matches, key, raw_value]- is_list? -> [:member, key, parse_member_list(raw_value)]- is_negated? -> [:is_not, key, final_value]- true -> [:is, key, final_value]+ is_wildcard? && is_negated? -> [:does_not_match, key, [raw_value]]+ is_wildcard? -> [:matches, key, [raw_value]]+ is_list? -> [:is, key, parse_member_list(raw_value)]+ is_negated? -> [:is_not, key, [final_value]]+ true -> [:is, key, [final_value]]end|> reject_invalid_country_codes()@@ -71,10 +71,10 @@ defmodule Plausible.Stats.Filters.StatsAPIFilterParser do|> wrap_goal_value()cond do- is_list? && is_wildcard? -> [:matches_member, key, value]- is_list? -> [:member, key, value]- is_wildcard? -> [:matches, key, value]- true -> [:is, key, value]+ is_list? && is_wildcard? -> [:matches, key, value]+ is_list? -> [:is, key, value]+ is_wildcard? -> [:matches, key, [value]]+ true -> [:is, key, [value]]endendenddiff --git a/lib/plausible/stats/filters/utils.ex b/lib/plausible/stats/filters/utils.exindex 5bb612b62e..396b62e13e 100644--- a/lib/plausible/stats/filters/utils.ex+++ b/lib/plausible/stats/filters/utils.ex@@ -1,6 +1,6 @@defmodule Plausible.Stats.Filters.Utils do@moduledoc """- Contains utility functions shared between `DashboardFilterParser`+ Contains utility functions shared between `LegacyDashboardFilterParser`and `StatsAPIFilterParser`."""diff --git a/lib/plausible/stats/filters/where_builder.ex b/lib/plausible/stats/filters/where_builder.exindex 04f66c8363..77a02f9136 100644--- a/lib/plausible/stats/filters/where_builder.ex+++ b/lib/plausible/stats/filters/where_builder.ex@@ -68,35 +68,17 @@ defmodule Plausible.Stats.Filters.WhereBuilder do)end- defp add_filter(:events, _query, [:is, "event:name", name]) do- dynamic([e], e.name == ^name)- end-- defp add_filter(:events, _query, [:member, "event:name", list]) do+ defp add_filter(:events, _query, [:is, "event:name", list]) dodynamic([e], e.name in ^list)end- defp add_filter(:events, _query, [:is, "event:goal", {:page, path}]) do- dynamic([e], e.pathname == ^path and e.name == "pageview")- end-- defp add_filter(:events, _query, [:matches, "event:goal", {:page, expr}]) do- regex = page_regex(expr)-- dynamic([e], fragment("match(?, ?)", e.pathname, ^regex) and e.name == "pageview")- end-- defp add_filter(:events, _query, [:is, "event:goal", {:event, event}]) do- dynamic([e], e.name == ^event)- end-- defp add_filter(:events, _query, [:member, "event:goal", clauses]) do+ defp add_filter(:events, _query, [:is, "event:goal", clauses]) do{events, pages} = split_goals(clauses)dynamic([e], (e.pathname in ^pages and e.name == "pageview") or e.name in ^events)end- defp add_filter(:events, _query, [:matches_member, "event:goal", clauses]) do+ defp add_filter(:events, _query, [:matches, "event:goal", clauses]) do{events, pages} = split_goals(clauses, &page_regex/1)event_clause =@@ -169,39 +151,7 @@ defmodule Plausible.Stats.Filters.WhereBuilder dotrueend- defp filter_custom_prop(prop_name, column_name, [:is, _, "(none)"]) do- dynamic([t], not has_key(t, column_name, ^prop_name))- end-- defp filter_custom_prop(prop_name, column_name, [:is, _, value]) do- dynamic(- [t],- has_key(t, column_name, ^prop_name) and get_by_key(t, column_name, ^prop_name) == ^value- )- end-- defp filter_custom_prop(prop_name, column_name, [:is_not, _, "(none)"]) do- dynamic([t], has_key(t, column_name, ^prop_name))- end-- defp filter_custom_prop(prop_name, column_name, [:is_not, _, value]) do- dynamic(- [t],- not has_key(t, column_name, ^prop_name) or get_by_key(t, column_name, ^prop_name) != ^value- )- end-- defp filter_custom_prop(prop_name, column_name, [:matches, _, value]) do- regex = page_regex(value)-- dynamic(- [t],- has_key(t, column_name, ^prop_name) and- fragment("match(?, ?)", get_by_key(t, column_name, ^prop_name), ^regex)- )- end-- defp filter_custom_prop(prop_name, column_name, [:member, _, values]) do+ defp filter_custom_prop(prop_name, column_name, [:is, _, values]) donone_value_included = Enum.member?(values, "(none)")dynamic(@@ -211,7 +161,7 @@ defmodule Plausible.Stats.Filters.WhereBuilder do)end- defp filter_custom_prop(prop_name, column_name, [:not_member, _, values]) do+ defp filter_custom_prop(prop_name, column_name, [:is_not, _, values]) donone_value_included = Enum.member?(values, "(none)")dynamic(@@ -225,7 +175,7 @@ defmodule Plausible.Stats.Filters.WhereBuilder do)end- defp filter_custom_prop(prop_name, column_name, [:matches_member, _, clauses]) do+ defp filter_custom_prop(prop_name, column_name, [:matches, _, clauses]) doregexes = Enum.map(clauses, &page_regex/1)dynamic(@@ -239,42 +189,22 @@ defmodule Plausible.Stats.Filters.WhereBuilder do)end- defp filter_field(db_field, [:is, _key, value]) do- value = db_field_val(db_field, value)- dynamic([x], field(x, ^db_field) == ^value)- end-- defp filter_field(db_field, [:is_not, _key, value]) do- value = db_field_val(db_field, value)- dynamic([x], field(x, ^db_field) != ^value)- end-- defp filter_field(db_field, [:matches_member, _key, glob_exprs]) do+ defp filter_field(db_field, [:matches, _key, glob_exprs]) dopage_regexes = Enum.map(glob_exprs, &page_regex/1)dynamic([x], fragment("multiMatchAny(?, ?)", field(x, ^db_field), ^page_regexes))end- defp filter_field(db_field, [:not_matches_member, _key, glob_exprs]) do+ defp filter_field(db_field, [:does_not_match, _key, glob_exprs]) dopage_regexes = Enum.map(glob_exprs, &page_regex/1)dynamic([x], fragment("not(multiMatchAny(?, ?))", field(x, ^db_field), ^page_regexes))end- defp filter_field(db_field, [:matches, _key, glob_expr]) do- regex = page_regex(glob_expr)- dynamic([x], fragment("match(?, ?)", field(x, ^db_field), ^regex))- end-- defp filter_field(db_field, [:does_not_match, _key, glob_expr]) do- regex = page_regex(glob_expr)- dynamic([x], fragment("not(match(?, ?))", field(x, ^db_field), ^regex))- end-- defp filter_field(db_field, [:member, _key, list]) do+ defp filter_field(db_field, [:is, _key, list]) dolist = Enum.map(list, &db_field_val(db_field, &1))dynamic([x], field(x, ^db_field) in ^list)end- defp filter_field(db_field, [:not_member, _key, list]) do+ defp filter_field(db_field, [:is_not, _key, list]) dolist = Enum.map(list, &db_field_val(db_field, &1))dynamic([x], field(x, ^db_field) not in ^list)enddiff --git a/lib/plausible/stats/imported/base.ex b/lib/plausible/stats/imported/base.exindex 539f3fb83c..a446817a37 100644--- a/lib/plausible/stats/imported/base.ex+++ b/lib/plausible/stats/imported/base.ex@@ -89,17 +89,11 @@ defmodule Plausible.Stats.Imported.Base donew_filters =query.filters|> Enum.reject(fn- [:is, "event:name", "pageview"] -> true+ [:is, "event:name", ["pageview"]] -> true_ -> falseend)|> Enum.flat_map(fn filter ->case filter do- [op, "event:goal", {:event, name}] ->- [[op, "event:name", name]]-- [op, "event:goal", {:page, page}] ->- [[op, "event:page", page]]-[op, "event:goal", events] ->events|> Enum.group_by(&elem(&1, 0), &elem(&1, 1))@@ -119,44 +113,48 @@ defmodule Plausible.Stats.Imported.Base dodefp custom_prop_query?(query) doquery.filters|> Enum.map(&Enum.at(&1, 1))- |> Enum.concat([query.property])+ |> Enum.concat(query.dimensions)|> Enum.any?(&(&1 in @imported_custom_props))end- defp do_decide_custom_prop_table(%{property: property} = query)- when property in @imported_custom_props do- do_decide_custom_prop_table(query, property)+ defp do_decide_custom_prop_table(%{dimensions: [dimension]} = query)+ when dimension in @imported_custom_props do+ do_decide_custom_prop_table(query, dimension)end- defp do_decide_custom_prop_table(%{property: property} = query)- when property in [nil, "event:goal", "event:name"] do- custom_prop_filters =- query.filters- |> Enum.map(&Enum.at(&1, 1))- |> Enum.filter(&(&1 in @imported_custom_props))- |> Enum.uniq()-- case custom_prop_filters do- [custom_prop_filter] ->- do_decide_custom_prop_table(query, custom_prop_filter)-- _ ->- nil+ defp do_decide_custom_prop_table(%{dimensions: dimensions} = query) do+ if dimensions == [] or+ (length(dimensions) == 1 and hd(dimensions) in ["event:goal", "event:name"]) do+ custom_prop_filters =+ query.filters+ |> Enum.map(&Enum.at(&1, 1))+ |> Enum.filter(&(&1 in @imported_custom_props))+ |> Enum.uniq()++ case custom_prop_filters do+ [custom_prop_filter] ->+ do_decide_custom_prop_table(query, custom_prop_filter)++ _ ->+ nil+ end+ else+ nilendend- defp do_decide_custom_prop_table(_query), do: nil-defp do_decide_custom_prop_table(query, property) dohas_required_name_filter? =- Enum.any?(query.filters, fn- [:is, "event:name", name] -> name in special_goals_for(property)- _ -> false+ query.filters+ |> Enum.flat_map(fn+ [:is, "event:name", names] -> names+ _ -> []end)+ |> Enum.any?(&(&1 in special_goals_for(property)))has_unsupported_filters? =- Enum.any?(query.filters, fn [_, filtered_prop | _] ->- filtered_prop not in [property, "event:name"]+ Enum.any?(query.filters, fn [_, filter_key | _] ->+ filter_key not in [property, "event:name"]end)if has_required_name_filter? and not has_unsupported_filters? do@@ -166,17 +164,17 @@ defmodule Plausible.Stats.Imported.Base doendend- defp do_decide_table(%Query{filters: [], property: nil}), do: "imported_visitors"+ defp do_decide_table(%Query{filters: [], dimensions: []}), do: "imported_visitors"- defp do_decide_table(%Query{filters: [], property: "event:goal"}) do+ defp do_decide_table(%Query{filters: [], dimensions: ["event:goal"]}) do"imported_custom_events"end- defp do_decide_table(%Query{filters: [], property: property}) do- @property_to_table_mappings[property]+ defp do_decide_table(%Query{filters: [], dimensions: [dimension]}) do+ @property_to_table_mappings[dimension]end- defp do_decide_table(%Query{filters: filters, property: "event:goal"}) do+ defp do_decide_table(%Query{filters: filters, dimensions: ["event:goal"]}) dofilter_props = Enum.map(filters, &Enum.at(&1, 1))any_event_name_filters? = "event:name" in filter_props@@ -191,11 +189,11 @@ defmodule Plausible.Stats.Imported.Base doendend- defp do_decide_table(%Query{filters: filters, property: property}) do+ defp do_decide_table(%Query{filters: filters, dimensions: dimensions}) dotable_candidates =filters- |> Enum.map(fn [_, prop | _] -> prop end)- |> Enum.concat(if property, do: [property], else: [])+ |> Enum.map(fn [_, filter_key | _] -> filter_key end)+ |> Enum.concat(dimensions)|> Enum.map(fn"visit:screen" -> "visit:device"prop -> prop@@ -209,8 +207,8 @@ defmodule Plausible.Stats.Imported.Base doenddefp apply_filter(q, %Query{filters: filters}) do- Enum.reduce(filters, q, fn [_, filtered_prop | _] = filter, q ->- db_field = Plausible.Stats.Filters.without_prefix(filtered_prop)+ Enum.reduce(filters, q, fn [_, filter_key | _] = filter, q ->+ db_field = Plausible.Stats.Filters.without_prefix(filter_key)mapped_db_field = Map.get(@db_field_mappings, db_field, db_field)condition = Filters.WhereBuilder.build_condition(mapped_db_field, filter)diff --git a/lib/plausible/stats/imported/imported.ex b/lib/plausible/stats/imported/imported.exindex a387ab1a24..2e680f824f 100644--- a/lib/plausible/stats/imported/imported.ex+++ b/lib/plausible/stats/imported/imported.ex@@ -266,9 +266,9 @@ defmodule Plausible.Stats.Imported dodef merge_imported(q, _, %Query{include_imported: false}, _), do: q- def merge_imported(q, site, %Query{property: property} = query, metrics)- when property in @imported_properties do- dim = Plausible.Stats.Filters.without_prefix(property)+ def merge_imported(q, site, %Query{dimensions: [dimension]} = query, metrics)+ when dimension in @imported_properties do+ dim = Plausible.Stats.Filters.without_prefix(dimension)imported_q =site@@ -302,7 +302,7 @@ defmodule Plausible.Stats.Imported do|> apply_order_by(metrics)end- def merge_imported(q, site, %Query{property: nil} = query, metrics) do+ def merge_imported(q, site, %Query{dimensions: []} = query, metrics) doimported_q =site|> Imported.Base.query_imported(query)diff --git a/lib/plausible/stats/query.ex b/lib/plausible/stats/query.exindex 7604169022..737b3ba0bf 100644--- a/lib/plausible/stats/query.ex+++ b/lib/plausible/stats/query.ex@@ -4,7 +4,7 @@ defmodule Plausible.Stats.Query dodefstruct date_range: nil,interval: nil,period: nil,- property: nil,+ dimensions: [],filters: [],sample_threshold: 20_000_000,imported_data_requested: false,@@ -30,7 +30,7 @@ defmodule Plausible.Stats.Query do|> put_experimental_session_count(site, params)|> put_experimental_reduced_joins(site, params)|> put_period(site, params)- |> put_breakdown_property(params)+ |> put_dimensions(params)|> put_interval(params)|> put_parsed_filters(params)|> put_imported_opts(site, params)@@ -185,8 +185,12 @@ defmodule Plausible.Stats.Query doput_period(query, site, Map.merge(params, %{"period" => "30d"}))end- defp put_breakdown_property(query, params) do- struct!(query, property: params["property"])+ defp put_dimensions(query, params) do+ if not is_nil(params["property"]) do+ struct!(query, dimensions: [params["property"]])+ else+ struct!(query, dimensions: Map.get(params, "dimensions", []))+ endenddefp put_interval(%{:period => "all"} = query, params) do@@ -203,10 +207,10 @@ defmodule Plausible.Stats.Query dostruct!(query, filters: Filters.parse(params["filters"]))end- @spec set_property(t(), String.t() | nil) :: t()- def set_property(query, property) do+ @spec set_dimensions(t(), list(String.t())) :: t()+ def set_dimensions(query, dimensions) doquery- |> struct!(property: property)+ |> struct!(dimensions: dimensions)|> refresh_imported_opts()end@@ -322,7 +326,7 @@ defmodule Plausible.Stats.Query doTracer.set_attributes([{"plausible.query.interval", query.interval},{"plausible.query.period", query.period},- {"plausible.query.breakdown_property", query.property},+ {"plausible.query.dimensions", query.dimensions |> Enum.join(";")},{"plausible.query.include_imported", query.include_imported},{"plausible.query.filter_keys", filter_keys},{"plausible.query.metrics", metrics}diff --git a/lib/plausible_web/controllers/api/external_stats_controller.ex b/lib/plausible_web/controllers/api/external_stats_controller.exindex f8145b8ccf..248f709baf 100644--- a/lib/plausible_web/controllers/api/external_stats_controller.ex+++ b/lib/plausible_web/controllers/api/external_stats_controller.ex@@ -124,14 +124,14 @@ defmodule PlausibleWeb.Api.ExternalStatsController doprop_filter = Query.get_filter_by_prefix(query, "event:props:")query_allowed? =- case {prop_filter, query.property, allowed_props} do+ case {prop_filter, query.dimensions, allowed_props} do{_, _, :all} ->true{[_, "event:props:" <> prop | _], _property, allowed_props} ->prop in allowed_props- {_filter, "event:props:" <> prop, allowed_props} ->+ {_filter, ["event:props:" <> prop], allowed_props} ->prop in allowed_props_ ->@@ -171,10 +171,10 @@ defmodule PlausibleWeb.Api.ExternalStatsController doQuery.get_filter(query, "event:name") ->{:error, "Metric `#{metric}` cannot be queried when filtering by `event:name`"}- query.property == "event:page" ->+ query.dimensions == ["event:page"] ->{:ok, metric}- not is_nil(query.property) ->+ not Enum.empty?(query.dimensions) ->{:error,"Metric `#{metric}` is not supported in breakdown queries (except `event:page` breakdown)"}@@ -189,7 +189,7 @@ defmodule PlausibleWeb.Api.ExternalStatsController dodefp validate_metric("conversion_rate" = metric, query) docond do- query.property == "event:goal" ->+ query.dimensions == ["event:goal"] ->{:ok, metric}Query.get_filter(query, "event:goal") ->@@ -210,7 +210,7 @@ defmodule PlausibleWeb.Api.ExternalStatsController doQuery.get_filter(query, "event:page") ->{:error, "Metric `#{metric}` cannot be queried with a filter on `event:page`."}- query.property != nil ->+ not Enum.empty?(query.dimensions) ->{:error, "Metric `#{metric}` is not supported in breakdown queries."}true ->@@ -230,9 +230,9 @@ defmodule PlausibleWeb.Api.ExternalStatsController dodefp validate_session_metric(metric, query) docond do- event_only_property?(query.property) ->+ length(query.dimensions) == 1 and event_only_property?(hd(query.dimensions)) ->{:error,- "Session metric `#{metric}` cannot be queried for breakdown by `#{query.property}`."}+ "Session metric `#{metric}` cannot be queried for breakdown by `#{query.dimensions}`."}event_only_filter = find_event_only_filter(query) ->{:error,diff --git a/lib/plausible_web/controllers/api/stats_controller.ex b/lib/plausible_web/controllers/api/stats_controller.exindex 6e09071477..5dcf7800cf 100644--- a/lib/plausible_web/controllers/api/stats_controller.ex+++ b/lib/plausible_web/controllers/api/stats_controller.ex@@ -6,7 +6,7 @@ defmodule PlausibleWeb.Api.StatsController doalias Plausible.Statsalias Plausible.Stats.{Query, Comparisons}- alias Plausible.Stats.Filters.DashboardFilterParser+ alias Plausible.Stats.Filters.LegacyDashboardFilterParseralias PlausibleWeb.Api.Helpers, as: Hrequire Logger@@ -769,7 +769,7 @@ defmodule PlausibleWeb.Api.StatsController dosite = conn.assigns[:site]params = Map.put(params, "property", "visit:referrer")- referrer_filter = DashboardFilterParser.filter_value("visit:source", referrer)+ referrer_filter = LegacyDashboardFilterParser.filter_value("visit:source", referrer)query =Query.from(site, params)@@ -903,9 +903,9 @@ defmodule PlausibleWeb.Api.StatsController dototal_pageviews_query =query|> Query.remove_filters(["visit:exit_page"])- |> Query.put_filter([:member, "event:page", pages])- |> Query.put_filter([:is, "event:name", "pageview"])- |> Query.set_property("event:page")+ |> Query.put_filter([:is, "event:page", pages])+ |> Query.put_filter([:is, "event:name", ["pageview"]])+ |> Query.set_dimensions(["event:page"])total_pageviews =Stats.breakdown(site, total_pageviews_query, [:pageviews], {limit, 1})diff --git a/lib/plausible_web/controllers/stats_controller.ex b/lib/plausible_web/controllers/stats_controller.exindex 1325fe642a..d92c934472 100644--- a/lib/plausible_web/controllers/stats_controller.ex+++ b/lib/plausible_web/controllers/stats_controller.ex@@ -367,7 +367,12 @@ defmodule PlausibleWeb.StatsController dodefp shared_link_cookie_name(slug), do: "shared-link-" <> slug- defp get_flags(_user, _site), do: %{}+ defp get_flags(user, site),+ do: %{+ multiple_filters:+ FunWithFlags.enabled?(:multiple_filters, for: user) ||+ FunWithFlags.enabled?(:multiple_filters, for: site)+ }defp is_dbip() doon_ee dodiff --git a/test/plausible/google/search_console/filters_test.exs b/test/plausible/google/search_console/filters_test.exsindex c6efffa069..265df74762 100644--- a/test/plausible/google/search_console/filters_test.exs+++ b/test/plausible/google/search_console/filters_test.exs@@ -4,19 +4,27 @@ defmodule Plausible.Google.SearchConsole.FiltersTest dotest "transforms simple page filter" dofilters = [- [:is, "visit:entry_page", "/page"]+ [:is, "visit:entry_page", ["/page"]]]{:ok, transformed} = Filters.transform("sc-domain:plausible.io", filters)assert transformed == [- %{filters: [%{dimension: "page", expression: "https://plausible.io/page"}]}+ %{+ filters: [+ %{+ dimension: "page",+ operator: "includingRegex",+ expression: "https://plausible.io/page"+ }+ ]+ }]endtest "transforms matches page filter" dofilters = [- [:matches, "visit:entry_page", "*page*"]+ [:matches, "visit:entry_page", ["*page*"]]]{:ok, transformed} = Filters.transform("sc-domain:plausible.io", filters)@@ -34,9 +42,9 @@ defmodule Plausible.Google.SearchConsole.FiltersTest do]end- test "transforms member page filter" do+ test "transforms is page filter" dofilters = [- [:member, "visit:entry_page", ["/pageA", "/pageB"]]+ [:is, "visit:entry_page", ["/pageA", "/pageB"]]]{:ok, transformed} = Filters.transform("sc-domain:plausible.io", filters)@@ -54,9 +62,9 @@ defmodule Plausible.Google.SearchConsole.FiltersTest do]end- test "transforms matches_member page filter" do+ test "transforms matches multiple page filter" dofilters = [- [:matches_member, "visit:entry_page", ["/pageA*", "/pageB*"]]+ [:matches, "visit:entry_page", ["/pageA*", "/pageB*"]]]{:ok, transformed} = Filters.transform("sc-domain:plausible.io", filters)@@ -76,7 +84,7 @@ defmodule Plausible.Google.SearchConsole.FiltersTest dotest "transforms event:page exactly like visit:entry_page" dofilters = [- [:matches_member, "event:page", ["/pageA*", "/pageB*"]]+ [:matches, "event:page", ["/pageA*", "/pageB*"]]]{:ok, transformed} = Filters.transform("sc-domain:plausible.io", filters)@@ -96,17 +104,23 @@ defmodule Plausible.Google.SearchConsole.FiltersTest dotest "transforms simple visit:screen filter" dofilters = [- [:is, "visit:screen", "Desktop"]+ [:is, "visit:screen", ["Desktop"]]]{:ok, transformed} = Filters.transform("sc-domain:plausible.io", filters)- assert transformed == [%{filters: [%{dimension: "device", expression: "DESKTOP"}]}]+ assert transformed == [+ %{+ filters: [+ %{dimension: "device", operator: "includingRegex", expression: "DESKTOP"}+ ]+ }+ ]end- test "transforms member visit:screen filter" do+ test "transforms is visit:screen filter" dofilters = [- [:member, "visit:screen", ["Mobile", "Tablet"]]+ [:is, "visit:screen", ["Mobile", "Tablet"]]]{:ok, transformed} = Filters.transform("sc-domain:plausible.io", filters)@@ -114,7 +128,7 @@ defmodule Plausible.Google.SearchConsole.FiltersTest doassert transformed == [%{filters: [- %{dimension: "device", operator: "includingRegex", expression: "Mobile|Tablet"}+ %{dimension: "device", operator: "includingRegex", expression: "MOBILE|TABLET"}]}]@@ -122,17 +136,19 @@ defmodule Plausible.Google.SearchConsole.FiltersTest dotest "transforms simple visit:country filter to alpha3" dofilters = [- [:is, "visit:country", "EE"]+ [:is, "visit:country", ["EE"]]]{:ok, transformed} = Filters.transform("sc-domain:plausible.io", filters)- assert transformed == [%{filters: [%{dimension: "country", expression: "EST"}]}]+ assert transformed == [+ %{filters: [%{dimension: "country", operator: "includingRegex", expression: "EST"}]}+ ]endtest "transforms member visit:country filter" dofilters = [- [:member, "visit:country", ["EE", "PL"]]+ [:is, "visit:country", ["EE", "PL"]]]{:ok, transformed} = Filters.transform("sc-domain:plausible.io", filters)@@ -148,9 +164,9 @@ defmodule Plausible.Google.SearchConsole.FiltersTest dotest "filters can be combined" dofilters = [- [:member, "visit:country", ["EE", "PL"]],- [:matches, "visit:entry_page", "*web-analytics*"],- [:is, "visit:screen", "Desktop"]+ [:is, "visit:country", ["EE", "PL"]],+ [:matches, "visit:entry_page", ["*web-analytics*"]],+ [:is, "visit:screen", ["Desktop"]]]{:ok, transformed} = Filters.transform("sc-domain:plausible.io", filters)@@ -158,7 +174,7 @@ defmodule Plausible.Google.SearchConsole.FiltersTest doassert transformed == [%{filters: [- %{dimension: "device", expression: "DESKTOP"},+ %{dimension: "device", operator: "includingRegex", expression: "DESKTOP"},%{dimension: "page",operator: "includingRegex",diff --git a/test/plausible/stats/dashboard_filter_parser_test.exs b/test/plausible/stats/dashboard_filter_parser_test.exsdeleted file mode 100644index 1602380f37..0000000000--- a/test/plausible/stats/dashboard_filter_parser_test.exs+++ /dev/null@@ -1,207 +0,0 @@-defmodule Plausible.Stats.DashboardFilterParserTest do- use ExUnit.Case, async: true- alias Plausible.Stats.Filters.DashboardFilterParser-- def assert_parsed(filters, expected_output) do- assert DashboardFilterParser.parse_and_prefix(filters) == expected_output- end-- describe "adding prefix" do- test "adds appropriate prefix to filter" do- %{"page" => "/"}- |> assert_parsed([[:is, "event:page", "/"]])-- %{"goal" => "Signup"}- |> assert_parsed([[:is, "event:goal", {:event, "Signup"}]])-- %{"goal" => "Visit /blog"}- |> assert_parsed([[:is, "event:goal", {:page, "/blog"}]])-- %{"source" => "Google"}- |> assert_parsed([[:is, "visit:source", "Google"]])-- %{"referrer" => "cnn.com"}- |> assert_parsed([[:is, "visit:referrer", "cnn.com"]])-- %{"utm_medium" => "search"}- |> assert_parsed([[:is, "visit:utm_medium", "search"]])-- %{"utm_source" => "bing"}- |> assert_parsed([[:is, "visit:utm_source", "bing"]])-- %{"utm_content" => "content"}- |> assert_parsed([[:is, "visit:utm_content", "content"]])-- %{"utm_term" => "term"}- |> assert_parsed([[:is, "visit:utm_term", "term"]])-- %{"screen" => "Desktop"}- |> assert_parsed([[:is, "visit:screen", "Desktop"]])-- %{"browser" => "Opera"}- |> assert_parsed([[:is, "visit:browser", "Opera"]])-- %{"browser_version" => "10.1"}- |> assert_parsed([[:is, "visit:browser_version", "10.1"]])-- %{"os" => "Linux"}- |> assert_parsed([[:is, "visit:os", "Linux"]])-- %{"os_version" => "13.0"}- |> assert_parsed([[:is, "visit:os_version", "13.0"]])-- %{"country" => "EE"}- |> assert_parsed([[:is, "visit:country", "EE"]])-- %{"region" => "EE-12"}- |> assert_parsed([[:is, "visit:region", "EE-12"]])-- %{"city" => "123"}- |> assert_parsed([[:is, "visit:city", "123"]])-- %{"entry_page" => "/blog"}- |> assert_parsed([[:is, "visit:entry_page", "/blog"]])-- %{"exit_page" => "/blog"}- |> assert_parsed([[:is, "visit:exit_page", "/blog"]])-- %{"props" => %{"cta" => "Top"}}- |> assert_parsed([[:is, "event:props:cta", "Top"]])-- %{"hostname" => "dummy.site"}- |> assert_parsed([[:is, "event:hostname", "dummy.site"]])- end- end-- describe "escaping pipe character" do- test "in simple is filter" do- %{"goal" => ~S(Foo \| Bar)}- |> assert_parsed([[:is, "event:goal", {:event, "Foo | Bar"}]])- end-- test "in member filter" do- %{"page" => ~S(/|\|)}- |> assert_parsed([[:member, "event:page", ["/", "|"]]])- end- end-- describe "is not filter type" do- test "simple is not filter" do- %{"page" => "!/"}- |> assert_parsed([[:is_not, "event:page", "/"]])-- %{"props" => %{"cta" => "!Top"}}- |> assert_parsed([[:is_not, "event:props:cta", "Top"]])- end- end-- describe "member filter type" do- test "simple member filter" do- %{"page" => "/|/blog"}- |> assert_parsed([[:member, "event:page", ["/", "/blog"]]])- end-- test "escaping pipe character" do- %{"page" => "/|\\|"}- |> assert_parsed([[:member, "event:page", ["/", "|"]]])- end-- test "mixed goals" do- %{"goal" => "Signup|Visit /thank-you"}- |> assert_parsed([[:member, "event:goal", [{:event, "Signup"}, {:page, "/thank-you"}]]])-- %{"goal" => "Visit /thank-you|Signup"}- |> assert_parsed([[:member, "event:goal", [{:page, "/thank-you"}, {:event, "Signup"}]]])- end- end-- describe "matches_member filter type" do- test "parses matches_member filter type" do- %{"page" => "/|/blog**"}- |> assert_parsed([[:matches_member, "event:page", ["/", "/blog**"]]])- end-- test "parses not_matches_member filter type" do- %{"page" => "!/|/blog**"}- |> assert_parsed([[:not_matches_member, "event:page", ["/", "/blog**"]]])- end- end-- describe "contains filter type" do- test "single contains" do- %{"page" => "~blog"}- |> assert_parsed([[:matches, "event:page", "**blog**"]])- end-- test "negated contains" do- %{"page" => "!~articles"}- |> assert_parsed([[:does_not_match, "event:page", "**articles**"]])- end-- test "contains member" do- %{"page" => "~articles|blog"}- |> assert_parsed([[:matches_member, "event:page", ["**articles**", "**blog**"]]])- end-- test "not contains member" do- %{"page" => "!~articles|blog"}- |> assert_parsed([[:not_matches_member, "event:page", ["**articles**", "**blog**"]]])- end- end-- describe "not_member filter type" do- test "simple not_member filter" do- %{"page" => "!/|/blog"}- |> assert_parsed([[:not_member, "event:page", ["/", "/blog"]]])- end-- test "mixed goals" do- %{"goal" => "!Signup|Visit /thank-you"}- |> assert_parsed([- [:not_member, "event:goal", [{:event, "Signup"}, {:page, "/thank-you"}]]- ])-- %{"goal" => "!Visit /thank-you|Signup"}- |> assert_parsed([- [:not_member, "event:goal", [{:page, "/thank-you"}, {:event, "Signup"}]]- ])- end- end-- describe "matches filter type" do- test "can be used with `goal` or `page` filters" do- %{"page" => "/blog/post-*"}- |> assert_parsed([[:matches, "event:page", "/blog/post-*"]])-- %{"goal" => "Visit /blog/post-*"}- |> assert_parsed([[:matches, "event:goal", {:page, "/blog/post-*"}]])- end-- test "other filters default to `is` even when wildcard is present" do- %{"country" => "Germa**"}- |> assert_parsed([[:is, "visit:country", "Germa**"]])- end- end-- describe "does_not_match filter type" do- test "can be used with `page` filter" do- %{"page" => "!/blog/post-*"}- |> assert_parsed([[:does_not_match, "event:page", "/blog/post-*"]])- end-- test "other filters default to is_not even when wildcard is present" do- %{"country" => "!Germa**"}- |> assert_parsed([[:is_not, "visit:country", "Germa**"]])- end- end-- describe "contains prefix filter type" do- test "can be used with any filter" do- %{"page" => "~/blog/post"}- |> assert_parsed([[:matches, "event:page", "**/blog/post**"]])-- %{"source" => "~facebook"}- |> assert_parsed([[:matches, "visit:source", "**facebook**"]])- end- end-enddiff --git a/test/plausible/stats/filters_test.exs b/test/plausible/stats/filters_test.exsindex aa5b77412f..a99423cd54 100644--- a/test/plausible/stats/filters_test.exs+++ b/test/plausible/stats/filters_test.exs@@ -12,70 +12,70 @@ defmodule Plausible.Stats.FiltersTest dodescribe "parses filter expression" dotest "simple positive" do"event:name==pageview"- |> assert_parsed([[:is, "event:name", "pageview"]])+ |> assert_parsed([[:is, "event:name", ["pageview"]]])endtest "simple negative" do"event:name!=pageview"- |> assert_parsed([[:is_not, "event:name", "pageview"]])+ |> assert_parsed([[:is_not, "event:name", ["pageview"]]])endtest "whitespace is trimmed" do" event:name == pageview "- |> assert_parsed([[:is, "event:name", "pageview"]])+ |> assert_parsed([[:is, "event:name", ["pageview"]]])endtest "wildcard" do"event:page==/blog/post-*"- |> assert_parsed([[:matches, "event:page", "/blog/post-*"]])+ |> assert_parsed([[:matches, "event:page", ["/blog/post-*"]]])endtest "negative wildcard" do"event:page!=/blog/post-*"- |> assert_parsed([[:does_not_match, "event:page", "/blog/post-*"]])+ |> assert_parsed([[:does_not_match, "event:page", ["/blog/post-*"]]])endtest "custom event goal" do"event:goal==Signup"- |> assert_parsed([[:is, "event:goal", {:event, "Signup"}]])+ |> assert_parsed([[:is, "event:goal", [{:event, "Signup"}]]])endtest "pageview goal" do"event:goal==Visit /blog"- |> assert_parsed([[:is, "event:goal", {:page, "/blog"}]])+ |> assert_parsed([[:is, "event:goal", [{:page, "/blog"}]]])end- test "member" do+ test "is" do"visit:country==FR|GB|DE"- |> assert_parsed([[:member, "visit:country", ["FR", "GB", "DE"]]])+ |> assert_parsed([[:is, "visit:country", ["FR", "GB", "DE"]]])endtest "member + wildcard" do"event:page==/blog**|/newsletter|/*/"- |> assert_parsed([[:matches, "event:page", "/blog**|/newsletter|/*/"]])+ |> assert_parsed([[:matches, "event:page", ["/blog**|/newsletter|/*/"]]])endtest "combined with \";\"" do"event:page==/blog**|/newsletter|/*/ ; visit:country==FR|GB|DE"|> assert_parsed([- [:matches, "event:page", "/blog**|/newsletter|/*/"],- [:member, "visit:country", ["FR", "GB", "DE"]]+ [:matches, "event:page", ["/blog**|/newsletter|/*/"]],+ [:is, "visit:country", ["FR", "GB", "DE"]]])endtest "escaping pipe character" do"utm_campaign==campaign \\| 1"- |> assert_parsed([[:is, "utm_campaign", "campaign | 1"]])+ |> assert_parsed([[:is, "utm_campaign", ["campaign | 1"]]])end- test "escaping pipe character in member filter" do+ test "escaping pipe character in is filter" do"utm_campaign==campaign \\| 1|campaign \\| 2"- |> assert_parsed([[:member, "utm_campaign", ["campaign | 1", "campaign | 2"]]])+ |> assert_parsed([[:is, "utm_campaign", ["campaign | 1", "campaign | 2"]]])end- test "keeps escape characters in member + wildcard filter" do+ test "keeps escape characters in is + wildcard filter" do"event:page==/**\\|page|/other/page"- |> assert_parsed([[:matches, "event:page", "/**\\|page|/other/page"]])+ |> assert_parsed([[:matches, "event:page", ["/**\\|page|/other/page"]]])endtest "gracefully fails to parse garbage" do@@ -98,4 +98,12 @@ defmodule Plausible.Stats.FiltersTest do|> assert_parsed([])endend++ describe "parses filters list" do+ test "simple" do+ [["is", "event:name", ["pageview"]]]+ |> Jason.encode!()+ |> assert_parsed([[:is, "event:name", ["pageview"]]])+ end+ endenddiff --git a/test/plausible/stats/legacy_dashboard_filter_parser_test.exs b/test/plausible/stats/legacy_dashboard_filter_parser_test.exsnew file mode 100644index 0000000000..8a3e94053a--- /dev/null+++ b/test/plausible/stats/legacy_dashboard_filter_parser_test.exs@@ -0,0 +1,201 @@+defmodule Plausible.Stats.LegacyDashboardFilterParserTest do+ use ExUnit.Case, async: true+ alias Plausible.Stats.Filters.LegacyDashboardFilterParser++ def assert_parsed(filters, expected_output) do+ assert LegacyDashboardFilterParser.parse_and_prefix(filters) == expected_output+ end++ describe "adding prefix" do+ test "adds appropriate prefix to filter" do+ %{"page" => "/"}+ |> assert_parsed([[:is, "event:page", ["/"]]])++ %{"goal" => "Signup"}+ |> assert_parsed([[:is, "event:goal", [{:event, "Signup"}]]])++ %{"goal" => "Visit /blog"}+ |> assert_parsed([[:is, "event:goal", [{:page, "/blog"}]]])++ %{"source" => "Google"}+ |> assert_parsed([[:is, "visit:source", ["Google"]]])++ %{"referrer" => "cnn.com"}+ |> assert_parsed([[:is, "visit:referrer", ["cnn.com"]]])++ %{"utm_medium" => "search"}+ |> assert_parsed([[:is, "visit:utm_medium", ["search"]]])++ %{"utm_source" => "bing"}+ |> assert_parsed([[:is, "visit:utm_source", ["bing"]]])++ %{"utm_content" => "content"}+ |> assert_parsed([[:is, "visit:utm_content", ["content"]]])++ %{"utm_term" => "term"}+ |> assert_parsed([[:is, "visit:utm_term", ["term"]]])++ %{"screen" => "Desktop"}+ |> assert_parsed([[:is, "visit:screen", ["Desktop"]]])++ %{"browser" => "Opera"}+ |> assert_parsed([[:is, "visit:browser", ["Opera"]]])++ %{"browser_version" => "10.1"}+ |> assert_parsed([[:is, "visit:browser_version", ["10.1"]]])++ %{"os" => "Linux"}+ |> assert_parsed([[:is, "visit:os", ["Linux"]]])++ %{"os_version" => "13.0"}+ |> assert_parsed([[:is, "visit:os_version", ["13.0"]]])++ %{"country" => "EE"}+ |> assert_parsed([[:is, "visit:country", ["EE"]]])++ %{"region" => "EE-12"}+ |> assert_parsed([[:is, "visit:region", ["EE-12"]]])++ %{"city" => "123"}+ |> assert_parsed([[:is, "visit:city", ["123"]]])++ %{"entry_page" => "/blog"}+ |> assert_parsed([[:is, "visit:entry_page", ["/blog"]]])++ %{"exit_page" => "/blog"}+ |> assert_parsed([[:is, "visit:exit_page", ["/blog"]]])++ %{"props" => %{"cta" => "Top"}}+ |> assert_parsed([[:is, "event:props:cta", ["Top"]]])++ %{"hostname" => "dummy.site"}+ |> assert_parsed([[:is, "event:hostname", ["dummy.site"]]])+ end+ end++ describe "escaping pipe character" do+ test "in simple is filter" do+ %{"goal" => ~S(Foo \| Bar)}+ |> assert_parsed([[:is, "event:goal", [{:event, "Foo | Bar"}]]])+ end++ test "in member filter" do+ %{"page" => ~S(/|\|)}+ |> assert_parsed([[:is, "event:page", ["/", "|"]]])+ end+ end++ describe "is not filter type" do+ test "simple is not filter" do+ %{"page" => "!/"}+ |> assert_parsed([[:is_not, "event:page", ["/"]]])++ %{"props" => %{"cta" => "!Top"}}+ |> assert_parsed([[:is_not, "event:props:cta", ["Top"]]])+ end+ end++ describe "is filter type" do+ test "simple is filter" do+ %{"page" => "/|/blog"}+ |> assert_parsed([[:is, "event:page", ["/", "/blog"]]])+ end++ test "escaping pipe character" do+ %{"page" => "/|\\|"}+ |> assert_parsed([[:is, "event:page", ["/", "|"]]])+ end++ test "mixed goals" do+ %{"goal" => "Signup|Visit /thank-you"}+ |> assert_parsed([[:is, "event:goal", [{:event, "Signup"}, {:page, "/thank-you"}]]])++ %{"goal" => "Visit /thank-you|Signup"}+ |> assert_parsed([[:is, "event:goal", [{:page, "/thank-you"}, {:event, "Signup"}]]])+ end+ end++ describe "matches filter type" do+ test "parses matches filter type" do+ %{"page" => "/|/blog**"}+ |> assert_parsed([[:matches, "event:page", ["/", "/blog**"]]])+ end++ test "parses not_matches filter type" do+ %{"page" => "!/|/blog**"}+ |> assert_parsed([[:does_not_match, "event:page", ["/", "/blog**"]]])+ end++ test "single matches" do+ %{"page" => "~blog"}+ |> assert_parsed([[:matches, "event:page", ["**blog**"]]])+ end++ test "negated matches" do+ %{"page" => "!~articles"}+ |> assert_parsed([[:does_not_match, "event:page", ["**articles**"]]])+ end++ test "matches member" do+ %{"page" => "~articles|blog"}+ |> assert_parsed([[:matches, "event:page", ["**articles**", "**blog**"]]])+ end++ test "not matches member" do+ %{"page" => "!~articles|blog"}+ |> assert_parsed([[:does_not_match, "event:page", ["**articles**", "**blog**"]]])+ end++ test "can be used with `goal` or `page` filters" do+ %{"page" => "/blog/post-*"}+ |> assert_parsed([[:matches, "event:page", ["/blog/post-*"]]])++ %{"goal" => "Visit /blog/post-*"}+ |> assert_parsed([[:matches, "event:goal", [{:page, "/blog/post-*"}]]])+ end++ test "other filters default to `is` even when wildcard is present" do+ %{"country" => "Germa**"}+ |> assert_parsed([[:is, "visit:country", ["Germa**"]]])+ end++ test "can be used with `page` filter" do+ %{"page" => "!/blog/post-*"}+ |> assert_parsed([[:does_not_match, "event:page", ["/blog/post-*"]]])+ end++ test "other filters default to is_not even when wildcard is present" do+ %{"country" => "!Germa**"}+ |> assert_parsed([[:is_not, "visit:country", ["Germa**"]]])+ end+ end++ describe "is_not filter type" do+ test "simple is_not filter" do+ %{"page" => "!/|/blog"}+ |> assert_parsed([[:is_not, "event:page", ["/", "/blog"]]])+ end++ test "mixed goals" do+ %{"goal" => "!Signup|Visit /thank-you"}+ |> assert_parsed([+ [:is_not, "event:goal", [{:event, "Signup"}, {:page, "/thank-you"}]]+ ])++ %{"goal" => "!Visit /thank-you|Signup"}+ |> assert_parsed([+ [:is_not, "event:goal", [{:page, "/thank-you"}, {:event, "Signup"}]]+ ])+ end+ end++ describe "contains prefix filter type" do+ test "can be used with any filter" do+ %{"page" => "~/blog/post"}+ |> assert_parsed([[:matches, "event:page", ["**/blog/post**"]]])++ %{"source" => "~facebook"}+ |> assert_parsed([[:matches, "visit:source", ["**facebook**"]]])+ end+ end+enddiff --git a/test/plausible/stats/query_parser_test.exs b/test/plausible/stats/query_parser_test.exsnew file mode 100644index 0000000000..39baead3f3--- /dev/null+++ b/test/plausible/stats/query_parser_test.exs@@ -0,0 +1,373 @@+defmodule Plausible.Stats.Filters.QueryParserTest do+ use ExUnit.Case, async: true+ alias Plausible.Stats.Filters+ import Plausible.Stats.Filters.QueryParser++ def check_success(params, expected_result) do+ assert parse(params) == {:ok, expected_result}+ end++ def check_error(params, expected_error_message) do+ {:error, message} = parse(params)+ assert message =~ expected_error_message+ end++ test "parsing empty map fails" do+ %{}+ |> check_error("No valid metrics passed")+ end++ describe "metrics validation" do+ test "valid metrics passed" do+ %{"metrics" => ["visitors", "events"], "date_range" => "all"}+ |> check_success(%{+ metrics: [:visitors, :events],+ date_range: "all",+ filters: [],+ dimensions: [],+ order_by: nil+ })+ end++ test "invalid metric passed" do+ %{"metrics" => ["visitors", "event:name"], "date_range" => "all"}+ |> check_error("Unknown metric '\"event:name\"'")+ end++ test "fuller list of metrics" do+ %{+ "metrics" => [+ "time_on_page",+ "conversion_rate",+ "visitors",+ "pageviews",+ "visits",+ "events",+ "bounce_rate",+ "visit_duration"+ ],+ "date_range" => "all"+ }+ |> check_success(%{+ metrics: [+ :time_on_page,+ :conversion_rate,+ :visitors,+ :pageviews,+ :visits,+ :events,+ :bounce_rate,+ :visit_duration+ ],+ date_range: "all",+ filters: [],+ dimensions: [],+ order_by: nil+ })+ end++ test "same metric queried multiple times" do+ %{"metrics" => ["events", "visitors", "visitors"], "date_range" => "all"}+ |> check_error(~r/Metrics cannot be queried multiple times/)+ end+ end++ describe "filters validation" do+ for operation <- [:is, :is_not, :matches, :does_not_match] do+ test "#{operation} filter" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "filters" => [+ [Atom.to_string(unquote(operation)), "event:name", ["foo"]]+ ]+ }+ |> check_success(%{+ metrics: [:visitors],+ date_range: "all",+ filters: [+ [unquote(operation), "event:name", ["foo"]]+ ],+ dimensions: [],+ order_by: nil+ })+ end++ test "#{operation} filter with invalid clause" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "filters" => [+ [Atom.to_string(unquote(operation)), "event:name", "foo"]+ ]+ }+ |> check_error(~r/Invalid filter/)+ end+ end++ test "filtering by invalid operation" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "filters" => [+ ["exists?", "event:name", ["foo"]]+ ]+ }+ |> check_error(~r/Unknown operator for filter/)+ end++ test "filtering by custom properties" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "filters" => [+ ["is", "event:props:foobar", ["value"]]+ ]+ }+ |> check_success(%{+ metrics: [:visitors],+ date_range: "all",+ filters: [+ [:is, "event:props:foobar", ["value"]]+ ],+ dimensions: [],+ order_by: nil+ })+ end++ for dimension <- Filters.event_props() do+ if dimension != "goal" do+ test "filtering by event:#{dimension} filter" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "filters" => [+ ["is", "event:#{unquote(dimension)}", ["foo"]]+ ]+ }+ |> check_success(%{+ metrics: [:visitors],+ date_range: "all",+ filters: [+ [:is, "event:#{unquote(dimension)}", ["foo"]]+ ],+ dimensions: [],+ order_by: nil+ })+ end+ end+ end++ for dimension <- Filters.visit_props() do+ test "filtering by visit:#{dimension} filter" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "filters" => [+ ["is", "visit:#{unquote(dimension)}", ["foo"]]+ ]+ }+ |> check_success(%{+ metrics: [:visitors],+ date_range: "all",+ filters: [+ [:is, "visit:#{unquote(dimension)}", ["foo"]]+ ],+ dimensions: [],+ order_by: nil+ })+ end+ end++ test "filtering by event:goal" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "filters" => [+ ["is", "event:goal", ["Signup", "Visit /thank-you"]]+ ]+ }+ |> check_success(%{+ metrics: [:visitors],+ date_range: "all",+ filters: [+ [:is, "event:goal", [{:event, "Signup"}, {:page, "/thank-you"}]]+ ],+ dimensions: [],+ order_by: nil+ })+ end++ test "invalid event filter" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "filters" => [+ ["is", "event:device", ["foo"]]+ ]+ }+ |> check_error(~r/Invalid filter /)+ end++ test "invalid visit filter" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "filters" => [+ ["is", "visit:name", ["foo"]]+ ]+ }+ |> check_error(~r/Invalid filter /)+ end++ test "invalid filter" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "filters" => "foobar"+ }+ |> check_error(~r/Invalid filters passed/)+ end+ end++ describe "date range validation" do+ end++ describe "dimensions validation" do+ for dimension <- Filters.event_props() do+ test "event:#{dimension} dimension" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "dimensions" => ["event:#{unquote(dimension)}"]+ }+ |> check_success(%{+ metrics: [:visitors],+ date_range: "all",+ filters: [],+ dimensions: ["event:#{unquote(dimension)}"],+ order_by: nil+ })+ end+ end++ for dimension <- Filters.visit_props() do+ test "visit:#{dimension} dimension" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "dimensions" => ["visit:#{unquote(dimension)}"]+ }+ |> check_success(%{+ metrics: [:visitors],+ date_range: "all",+ filters: [],+ dimensions: ["visit:#{unquote(dimension)}"],+ order_by: nil+ })+ end+ end++ test "custom properties dimension" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "dimensions" => ["event:props:foobar"]+ }+ |> check_success(%{+ metrics: [:visitors],+ date_range: "all",+ filters: [],+ dimensions: ["event:props:foobar"],+ order_by: nil+ })+ end++ test "invalid dimension name passed" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "dimensions" => ["visitors"]+ }+ |> check_error(~r/Invalid dimensions/)+ end++ test "invalid dimension" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "dimensions" => "foobar"+ }+ |> check_error(~r/Invalid dimensions/)+ end++ test "dimensions are not unique" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "dimensions" => ["event:name", "event:name"]+ }+ |> check_error(~r/Some dimensions are listed multiple times/)+ end+ end++ describe "order_by validation" do+ test "ordering by metric" do+ %{+ "metrics" => ["visitors", "events"],+ "date_range" => "all",+ "order_by" => [["events", "desc"], ["visitors", "asc"]]+ }+ |> check_success(%{+ metrics: [:visitors, :events],+ date_range: "all",+ filters: [],+ dimensions: [],+ order_by: [{:events, :desc}, {:visitors, :asc}]+ })+ end++ test "ordering by dimension" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "dimensions" => ["event:name"],+ "order_by" => [["event:name", "desc"]]+ }+ |> check_success(%{+ metrics: [:visitors],+ date_range: "all",+ filters: [],+ dimensions: ["event:name"],+ order_by: [{"event:name", :desc}]+ })+ end++ test "ordering by invalid value" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "order_by" => [["visssss", "desc"]]+ }+ |> check_error(~r/Invalid order_by entry/)+ end++ test "ordering by not queried metric" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "order_by" => [["events", "desc"]]+ }+ |> check_error(~r/Entry is not a queried metric or dimension/)+ end++ test "ordering by not queried dimension" do+ %{+ "metrics" => ["visitors"],+ "date_range" => "all",+ "order_by" => [["event:name", "desc"]]+ }+ |> check_error(~r/Entry is not a queried metric or dimension/)+ end+ end+enddiff --git a/test/plausible/stats/query_test.exs b/test/plausible/stats/query_test.exsindex 629ea03449..62c919319f 100644--- a/test/plausible/stats/query_test.exs+++ b/test/plausible/stats/query_test.exs@@ -194,14 +194,14 @@ defmodule Plausible.Stats.QueryTest dofilters = Jason.encode!(%{"goal" => "Signup"})q = Query.from(site, %{"period" => "6mo", "filters" => filters})- assert q.filters == [[:is, "event:goal", {:event, "Signup"}]]+ assert q.filters == [[:is, "event:goal", [{:event, "Signup"}]]]endtest "parses source filter", %{site: site} dofilters = Jason.encode!(%{"source" => "Twitter"})q = Query.from(site, %{"period" => "6mo", "filters" => filters})- assert q.filters == [[:is, "visit:source", "Twitter"]]+ assert q.filters == [[:is, "visit:source", ["Twitter"]]]endend