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
DashboardQueryParser & DashboardQuerySerializer (#5938)
RobertJoonasd6673fbbd510
diff --git a/assets/js/dashboard/util/url-search-params.ts b/assets/js/dashboard/util/url-search-params.tsindex 730d8effdb..1ade67ed80 100644--- a/assets/js/dashboard/util/url-search-params.ts+++ b/assets/js/dashboard/util/url-search-params.ts@@ -3,7 +3,7 @@ import { v1 } from './url-search-params-v1'import { v2 } from './url-search-params-v2'/**- * These charcters are not URL encoded to have more readable URLs.+ * These characters are not URL encoded to have more readable URLs.* Browsers seem to handle this just fine.* `?f=is,page,/my/page/:some_param` vs `?f=is,page,%2Fmy%2Fpage%2F%3Asome_param``*/diff --git a/lib/plausible/stats/api_query_parser.ex b/lib/plausible/stats/api_query_parser.exindex 16cb1ddfad..60fe483037 100644--- a/lib/plausible/stats/api_query_parser.ex+++ b/lib/plausible/stats/api_query_parser.ex@@ -5,8 +5,23 @@ defmodule Plausible.Stats.ApiQueryParser doalias Plausible.Stats.{Filters, Metrics, DateTimeRange, JSONSchema}+ @default_include %{+ imports: false,+ imports_meta: false,+ time_labels: false,+ total_rows: false,+ trim_relative_date_range: false,+ comparisons: nil,+ legacy_time_on_page_cutoff: nil+ }++ def default_include(), do: @default_include++ @default_pagination %{limit: 10_000, offset: 0}++ def default_pagination(), do: @default_pagination+def parse(schema_type, params) when is_map(params) do- now = Plausible.Stats.Query.Test.get_fixed_now()input_date_range = Map.get(params, "date_range")with :ok <- JSONSchema.validate(schema_type, params),@@ -19,7 +34,6 @@ defmodule Plausible.Stats.ApiQueryParser do{:ok, include} <- parse_include(params["include"]) do{:ok,Plausible.Stats.ParsedQueryParams.new!(%{- now: now,input_date_range: input_date_range,metrics: metrics,filters: filters,@@ -61,7 +75,7 @@ defmodule Plausible.Stats.ApiQueryParser doparse_list(filters, &parse_filter/1)end- def parse_filters(nil), do: {:ok, nil}+ def parse_filters(nil), do: {:ok, []}defp parse_filter(filter) dowith {:ok, operator} <- parse_operator(filter),@@ -208,7 +222,7 @@ defmodule Plausible.Stats.ApiQueryParser do)end- defp parse_dimensions(nil), do: {:ok, nil}+ defp parse_dimensions(nil), do: {:ok, []}def parse_order_by(order_by) when is_list(order_by) doparse_list(order_by, &parse_order_by_entry/1)@@ -261,17 +275,18 @@ defmodule Plausible.Stats.ApiQueryParser dodefp parse_order_direction(entry), do: {:error, "Invalid order_by entry '#{i(entry)}'."}def parse_include(include) when is_map(include) do- with {:ok, include} <- atomize_include_keys(include) do- parse_comparison_date_range(include)+ with {:ok, include} <- atomize_include_keys(include),+ {:ok, include} <- parse_comparison_date_range(include) do+ {:ok, Map.merge(@default_include, include)}endend- def parse_include(nil), do: {:ok, nil}+ def parse_include(nil), do: {:ok, @default_include}def parse_include(include), do: {:error, "Invalid include '#{i(include)}'."}defp atomize_include_keys(map) doexpected_keys =- Plausible.Stats.ParsedQueryParams.default_include()+ @default_include|> Map.keys()|> Enum.map(&Atom.to_string/1)@@ -291,11 +306,10 @@ defmodule Plausible.Stats.ApiQueryParser dodefp parse_comparison_date_range(include), do: {:ok, include}defp parse_pagination(pagination) when is_map(pagination) do- {:ok,- Map.merge(Plausible.Stats.ParsedQueryParams.default_pagination(), atomize_keys(pagination))}+ {:ok, Map.merge(@default_pagination, atomize_keys(pagination))}end- defp parse_pagination(nil), do: {:ok, nil}+ defp parse_pagination(nil), do: {:ok, @default_pagination}defp atomize_keys(map) when is_map(map) doMap.new(map, fn {key, value} ->diff --git a/lib/plausible/stats/dashboard_query_parser.ex b/lib/plausible/stats/dashboard_query_parser.exnew file mode 100644index 0000000000..3108fb5d81--- /dev/null+++ b/lib/plausible/stats/dashboard_query_parser.ex@@ -0,0 +1,129 @@+defmodule Plausible.Stats.DashboardQueryParser do+ @moduledoc """+ Parses a dashboard query string into `%ParsedQueryParams{}`. Note that+ `metrics` and `dimensions` do not exist at this step yet, and are expected+ to be filled in by each specific report.+ """++ alias Plausible.Stats.{ParsedQueryParams}++ @default_include %{+ imports: true,+ # `include.imports_meta` can be true even when `include.imports`+ # is false. Even if we don't want to include imported data, we+ # might still want to know whether imported data can be toggled+ # on/off on the dashboard.+ imports_meta: true,+ time_labels: true,+ total_rows: false,+ trim_relative_date_range: true,+ comparisons: nil,+ legacy_time_on_page_cutoff: nil+ }++ def default_include(), do: @default_include++ @default_pagination nil++ def default_pagination(), do: @default_pagination++ def parse(query_string) when is_binary(query_string) do+ query_string = String.trim_leading(query_string, "?")+ params_map = URI.decode_query(query_string)++ with {:ok, filters} <- parse_filters(query_string),+ {:ok, relative_date} <- parse_relative_date(params_map) do+ include_imports? = parse_include_imports(params_map)++ {:ok,+ ParsedQueryParams.new!(%{+ input_date_range: parse_input_date_range(params_map),+ relative_date: relative_date,+ filters: filters,+ include: Map.merge(@default_include, %{imports: include_imports?})+ })}+ end+ end++ defp parse_input_date_range(%{"period" => "realtime"}), do: :realtime+ defp parse_input_date_range(%{"period" => "day"}), do: :day+ defp parse_input_date_range(%{"period" => "month"}), do: :month+ defp parse_input_date_range(%{"period" => "year"}), do: :year+ defp parse_input_date_range(%{"period" => "all"}), do: :all+ defp parse_input_date_range(%{"period" => "7d"}), do: {:last_n_days, 7}+ defp parse_input_date_range(%{"period" => "28d"}), do: {:last_n_days, 28}+ defp parse_input_date_range(%{"period" => "30d"}), do: {:last_n_days, 30}+ defp parse_input_date_range(%{"period" => "91d"}), do: {:last_n_days, 91}+ defp parse_input_date_range(%{"period" => "6mo"}), do: {:last_n_months, 6}+ defp parse_input_date_range(%{"period" => "12mo"}), do: {:last_n_months, 12}++ defp parse_input_date_range(%{"period" => "custom", "from" => from, "to" => to}) do+ from_date = Date.from_iso8601!(String.trim(from))+ to_date = Date.from_iso8601!(String.trim(to))+ {:date_range, from_date, to_date}+ end++ defp parse_input_date_range(_), do: nil++ defp parse_relative_date(%{"date" => date}) do+ case Date.from_iso8601(date) do+ {:ok, date} -> {:ok, date}+ _ -> {:error, :invalid_date}+ end+ end++ defp parse_relative_date(_), do: {:ok, nil}++ defp parse_include_imports(%{"with_imported" => "false"}), do: false+ defp parse_include_imports(_), do: true++ defp parse_filters(query_string) do+ with {:ok, filters} <- decode_filters(query_string) do+ Plausible.Stats.ApiQueryParser.parse_filters(filters)+ end+ end++ defp decode_filters(query_string) do+ query_string+ |> URI.query_decoder()+ |> Enum.filter(fn {key, _value} -> key == "f" end)+ |> Enum.reduce_while({:ok, []}, fn {_, filter_expression}, {:ok, acc} ->+ case decode_filter(filter_expression) do+ {:ok, filter} -> {:cont, {:ok, acc ++ [filter]}}+ {:error, _} -> {:halt, {:error, :invalid_filters}}+ end+ end)+ end++ defp decode_filter(filter_expression) do+ case String.split(filter_expression, ",") do+ [operator, dimension | clauses] ->+ {:ok,+ [+ operator,+ with_prefix(dimension),+ Enum.map(clauses, &URI.decode_www_form/1)+ ]}++ _ ->+ {:error, :invalid_filter}+ end+ end++ @event_prefix "event:"+ @visit_prefix "visit:"+ @no_prefix_dimensions ["segment"]+ defp with_prefix(dimension) do+ cond do+ dimension in @no_prefix_dimensions -> dimension+ event_dimension?(dimension) -> @event_prefix <> dimension+ true -> @visit_prefix <> dimension+ end+ end++ @event_props_prefix "props:"+ @event_dimensions ["name", "page", "goal", "hostname"]+ defp event_dimension?(dimension) do+ dimension in @event_dimensions or String.starts_with?(dimension, @event_props_prefix)+ end+enddiff --git a/lib/plausible/stats/dashboard_query_serializer.ex b/lib/plausible/stats/dashboard_query_serializer.exnew file mode 100644index 0000000000..f04bf60c24--- /dev/null+++ b/lib/plausible/stats/dashboard_query_serializer.ex@@ -0,0 +1,85 @@+defmodule Plausible.Stats.DashboardQuerySerializer do+ @moduledoc """+ Takes a `%ParsedQueryParams{}` struct and turns it into a query+ string.+ """++ alias Plausible.Stats.{ParsedQueryParams, DashboardQueryParser}++ def serialize(%ParsedQueryParams{} = params) do+ params+ |> Map.to_list()+ |> Enum.flat_map(&get_serialized_fields/1)+ |> Enum.sort_by(&elem(&1, 0))+ |> Enum.map_join("&", fn {key, value} -> "#{key}=#{value}" end)+ end++ defp get_serialized_fields({_, nil}), do: []+ defp get_serialized_fields({_, []}), do: []++ defp get_serialized_fields({:input_date_range, {:date_range, from_date, to_date}}) do+ [+ {"period", "custom"},+ {"from", Date.to_iso8601(from_date)},+ {"to", Date.to_iso8601(to_date)}+ ]+ end++ defp get_serialized_fields({:input_date_range, input_date_range}) do+ period =+ case input_date_range do+ :realtime -> "realtime"+ :day -> "day"+ :month -> "month"+ :year -> "year"+ :all -> "all"+ {:last_n_days, 7} -> "7d"+ {:last_n_days, 28} -> "28d"+ {:last_n_days, 30} -> "30d"+ {:last_n_days, 91} -> "91d"+ {:last_n_months, 6} -> "6mo"+ {:last_n_months, 12} -> "12mo"+ end++ [{"period", period}]+ end++ defp get_serialized_fields({:relative_date, date}) do+ [{"date", Date.to_iso8601(date)}]+ end++ defp get_serialized_fields({:filters, [_ | _] = filters}) do+ filters+ |> Enum.map(fn [operator, dimension, clauses] ->+ clauses = Enum.map_join(clauses, ",", &uri_encode_permissive/1)+ dimension = String.split(dimension, ":", parts: 2) |> List.last()+ {"f", "#{operator},#{dimension},#{clauses}"}+ end)+ end++ defp get_serialized_fields({:include, include}) do+ if include.imports == DashboardQueryParser.default_include().imports do+ []+ else+ [{"with_imported", to_string(include.imports)}]+ end+ end++ defp get_serialized_fields(_) do+ []+ end++ # These characters are not URL encoded to have more readable URLs.+ # Browsers seem to handle this just fine. `?f=is,page,/my/page/:some_param`+ # vs `?f=is,page,%2Fmy%2Fpage%2F%3Asome_param`+ @do_not_url_encode [":", "/"]+ @do_not_url_encode_map Enum.into(@do_not_url_encode, %{}, fn char ->+ {URI.encode_www_form(char), char}+ end)++ defp uri_encode_permissive(input) do+ input+ |> URI.encode_www_form()+ |> String.replace(Map.keys(@do_not_url_encode_map), &@do_not_url_encode_map[&1])+ end+enddiff --git a/lib/plausible/stats/legacy/legacy_query_builder.ex b/lib/plausible/stats/legacy/legacy_query_builder.exindex 35bc19b7fc..ff033a267f 100644--- a/lib/plausible/stats/legacy/legacy_query_builder.ex+++ b/lib/plausible/stats/legacy/legacy_query_builder.ex@@ -281,10 +281,10 @@ defmodule Plausible.Stats.Legacy.QueryBuilder do@doc """### Examples:iex> Plausible.Stats.Legacy.QueryBuilder.parse_include(nil)- Plausible.Stats.ParsedQueryParams.default_include()+ Plausible.Stats.ApiQueryParser.default_include()iex> Plausible.Stats.Legacy.QueryBuilder.parse_include(~s({"total_rows": true}))- Map.merge(Plausible.Stats.ParsedQueryParams.default_include(), %{total_rows: true})+ Map.merge(Plausible.Stats.ApiQueryParser.default_include(), %{total_rows: true})"""def parse_include(include) doinclude =@@ -296,7 +296,7 @@ defmodule Plausible.Stats.Legacy.QueryBuilder do_ -> %{}end- Plausible.Stats.ParsedQueryParams.default_include()+ Plausible.Stats.ApiQueryParser.default_include()|> Map.merge(include)enddiff --git a/lib/plausible/stats/parsed_query_params.ex b/lib/plausible/stats/parsed_query_params.exindex 997ebe0857..09f9152f5d 100644--- a/lib/plausible/stats/parsed_query_params.ex+++ b/lib/plausible/stats/parsed_query_params.ex@@ -2,8 +2,13 @@ defmodule Plausible.Stats.ParsedQueryParams do@moduledoc falsedefstruct [- :now,:input_date_range,+ # `relative_date` is a convenience currently exclusive to the internal+ # dashboard API for constructing datetime ranges. It adds the ability+ # to use `day`, `month` and `year` periods relative to a specific date.+ # E.g.: `?period=month&date=2021-01-15` will query the entire month of+ # January 2021. In the public API it is always today in site.timezone.+ :relative_date,:metrics,:filters,:dimensions,@@ -12,41 +17,7 @@ defmodule Plausible.Stats.ParsedQueryParams do:include]- @default_include %{- imports: false,- # `include.imports_meta` can be true even when `include.imports`- # is false. Even if we don't want to include imported data, we- # might still want to know whether imported data can be toggled- # on/off on the dashboard.- imports_meta: false,- time_labels: false,- total_rows: false,- trim_relative_date_range: false,- comparisons: nil,- legacy_time_on_page_cutoff: nil- }-- def default_include(), do: @default_include-- @default_pagination %{- limit: 10_000,- offset: 0- }-- def default_pagination(), do: @default_pagination-def new!(params) when is_map(params) do- [_ | _] = metrics = Map.fetch!(params, :metrics)-- %__MODULE__{- now: params[:now],- input_date_range: Map.fetch!(params, :input_date_range),- metrics: metrics,- filters: params[:filters] || [],- dimensions: params[:dimensions] || [],- order_by: params[:order_by],- pagination: Map.merge(@default_pagination, params[:pagination] || %{}),- include: Map.merge(@default_include, params[:include] || %{})- }+ struct!(__MODULE__, Map.to_list(params))endenddiff --git a/lib/plausible/stats/query.ex b/lib/plausible/stats/query.exindex f628e33ea1..e6482e050e 100644--- a/lib/plausible/stats/query.ex+++ b/lib/plausible/stats/query.ex@@ -18,7 +18,7 @@ defmodule Plausible.Stats.Query dotimezone: nil,legacy_breakdown: false,preloaded_goals: [],- include: Plausible.Stats.ParsedQueryParams.default_include(),+ include: Plausible.Stats.ApiQueryParser.default_include(),debug_metadata: %{},pagination: nil,# Revenue metric specific metadatadiff --git a/lib/plausible/stats/query_builder.ex b/lib/plausible/stats/query_builder.exindex 4fbf8d9a38..e92893a851 100644--- a/lib/plausible/stats/query_builder.ex+++ b/lib/plausible/stats/query_builder.ex@@ -54,7 +54,7 @@ defmodule Plausible.Stats.QueryBuilder doendend- defp build_datetime_range(input_date_range, _site, now)+ defp build_datetime_range(input_date_range, _site, _relative_date, now)when input_date_range in [:realtime, :realtime_30m] doduration_minutes =case input_date_range do@@ -68,50 +68,44 @@ defmodule Plausible.Stats.QueryBuilder doDateTimeRange.new!(first_datetime, last_datetime)end- defp build_datetime_range(:day, site, now) do- today = today_from_now(site, now)- DateTimeRange.new!(today, today, site.timezone)+ defp build_datetime_range(:day, site, relative_date, _now) do+ DateTimeRange.new!(relative_date, relative_date, site.timezone)end- defp build_datetime_range(:month, site, now) do- today = today_from_now(site, now)- first = today |> Date.beginning_of_month()- last = today |> Date.end_of_month()+ defp build_datetime_range(:month, site, relative_date, _now) do+ first = relative_date |> Date.beginning_of_month()+ last = relative_date |> Date.end_of_month()DateTimeRange.new!(first, last, site.timezone)end- defp build_datetime_range(:year, site, now) do- today = today_from_now(site, now)- first = today |> Plausible.Times.beginning_of_year()- last = today |> Plausible.Times.end_of_year()+ defp build_datetime_range(:year, site, relative_date, _now) do+ first = relative_date |> Plausible.Times.beginning_of_year()+ last = relative_date |> Plausible.Times.end_of_year()DateTimeRange.new!(first, last, site.timezone)end- defp build_datetime_range(:all, site, now) do- today = today_from_now(site, now)- start_date = Plausible.Sites.stats_start_date(site) || today- DateTimeRange.new!(start_date, today, site.timezone)+ defp build_datetime_range(:all, site, relative_date, _now) do+ start_date = Plausible.Sites.stats_start_date(site) || relative_date+ DateTimeRange.new!(start_date, relative_date, site.timezone)end- defp build_datetime_range({:last_n_days, n}, site, now) do- today = today_from_now(site, now)- last = today |> Date.add(-1)- first = today |> Date.add(-n)+ defp build_datetime_range({:last_n_days, n}, site, relative_date, _now) do+ last = relative_date |> Date.add(-1)+ first = relative_date |> Date.add(-n)DateTimeRange.new!(first, last, site.timezone)end- defp build_datetime_range({:last_n_months, n}, site, now) do- today = today_from_now(site, now)- last = today |> Date.shift(month: -1) |> Date.end_of_month()- first = today |> Date.shift(month: -n) |> Date.beginning_of_month()+ defp build_datetime_range({:last_n_months, n}, site, relative_date, _now) do+ last = relative_date |> Date.shift(month: -1) |> Date.end_of_month()+ first = relative_date |> Date.shift(month: -n) |> Date.beginning_of_month()DateTimeRange.new!(first, last, site.timezone)end- defp build_datetime_range({:date_range, from, to}, site, _now) do+ defp build_datetime_range({:date_range, from, to}, site, _relative_date, _now) doDateTimeRange.new!(from, to, site.timezone)end- defp build_datetime_range({:datetime_range, from, to}, _site, _now) do+ defp build_datetime_range({:datetime_range, from, to}, _site, _relative_date, _now) doDateTimeRange.new!(from, to)end@@ -120,7 +114,7 @@ defmodule Plausible.Stats.QueryBuilder doparsed_query_params,site) do- comparison_date_range = build_datetime_range(date_range, site, parsed_query_params.now)+ comparison_date_range = build_datetime_range(date_range, site, nil, nil)new_include =put_in(parsed_query_params.include, [:comparisons, :date_range], comparison_date_range)@@ -133,9 +127,11 @@ defmodule Plausible.Stats.QueryBuilder doenddefp do_build(parsed_query_params, site, debug_metadata) do+ now = Plausible.Stats.Query.Test.get_fixed_now()+%ParsedQueryParams{input_date_range: input_date_range,- now: now,+ relative_date: relative_date,metrics: metrics,filters: filters,dimensions: dimensions@@ -143,9 +139,11 @@ defmodule Plausible.Stats.QueryBuilder doparsed_query_params = build_comparison_datetime_range(parsed_query_params, site)+ relative_date = relative_date || today_from_now(site, now)+utc_time_range =input_date_range- |> build_datetime_range(site, now)+ |> build_datetime_range(site, relative_date, now)|> DateTimeRange.to_timezone("Etc/UTC"){preloaded_goals, revenue_warning, revenue_currencies} =@@ -153,22 +151,25 @@ defmodule Plausible.Stats.QueryBuilder doconsolidated_site_ids = get_consolidated_site_ids(site)- all_params =- parsed_query_params- |> Map.to_list()- |> Keyword.merge(- site_id: site.id,- site_native_stats_start_at: site.native_stats_start_at,- consolidated_site_ids: consolidated_site_ids,- timezone: site.timezone,- preloaded_goals: preloaded_goals,- revenue_warning: revenue_warning,- revenue_currencies: revenue_currencies,- utc_time_range: utc_time_range,- debug_metadata: debug_metadata- )-- struct!(%Query{}, all_params)+ struct!(%Query{},+ now: now,+ input_date_range: input_date_range,+ utc_time_range: utc_time_range,+ site_id: site.id,+ metrics: metrics,+ dimensions: dimensions,+ filters: filters,+ order_by: parsed_query_params.order_by,+ pagination: parsed_query_params.pagination,+ include: parsed_query_params.include,+ site_native_stats_start_at: site.native_stats_start_at,+ consolidated_site_ids: consolidated_site_ids,+ timezone: site.timezone,+ preloaded_goals: preloaded_goals,+ revenue_warning: revenue_warning,+ revenue_currencies: revenue_currencies,+ debug_metadata: debug_metadata+ )endon_ee dodiff --git a/test/plausible/stats/query/query_parser_test.exs b/test/plausible/stats/query/api_query_parser_test.exssimilarity index 100%rename from test/plausible/stats/query/query_parser_test.exsrename to test/plausible/stats/query/api_query_parser_test.exsdiff --git a/test/plausible/stats/query/dashboard_query_parser_test.exs b/test/plausible/stats/query/dashboard_query_parser_test.exsnew file mode 100644index 0000000000..8a0dc77852--- /dev/null+++ b/test/plausible/stats/query/dashboard_query_parser_test.exs@@ -0,0 +1,110 @@+defmodule Plausible.Stats.DashboardQueryParserTest do+ use Plausible.DataCase+ import Plausible.Stats.DashboardQueryParser+ alias Plausible.Stats.ParsedQueryParams++ test "parses an empty query string" do+ {:ok, parsed} = parse("")++ expected = %Plausible.Stats.ParsedQueryParams{+ input_date_range: nil,+ relative_date: nil,+ metrics: nil,+ filters: [],+ dimensions: nil,+ order_by: nil,+ pagination: nil,+ include: default_include()+ }++ assert parsed == expected+ end++ describe "period -> input_date_range" do+ for period <- [:realtime, :day, :month, :year, :all] do+ test "parses #{period} period" do+ {:ok, parsed} = parse("?period=#{Atom.to_string(unquote(period))}")+ assert_matches %ParsedQueryParams{input_date_range: ^unquote(period)} = parsed+ end+ end++ for i <- [7, 28, 30, 91] do+ test "parses #{i}d period" do+ {:ok, parsed} = parse("?period=#{unquote(i)}d")+ assert_matches %ParsedQueryParams{input_date_range: {:last_n_days, ^unquote(i)}} = parsed+ end+ end++ for i <- [6, 12] do+ test "parses #{i}mo period" do+ {:ok, parsed} = parse("?period=#{unquote(i)}mo")++ assert_matches %ParsedQueryParams{input_date_range: {:last_n_months, ^unquote(i)}} =+ parsed+ end+ end++ test "parses custom period" do+ {:ok, parsed} = parse("?period=custom&from=2021-01-01&to=2021-03-05")++ assert %ParsedQueryParams{+ input_date_range: {:date_range, ~D[2021-01-01], ~D[2021-03-05]}+ } = parsed+ end++ test "defaults to nil when period param is invalid" do+ {:ok, parsed} = parse("?period=abcde")++ assert %ParsedQueryParams{+ input_date_range: nil+ } = parsed+ end+ end++ describe "date -> relative_date" do+ test "parses a valid iso8601 date string" do+ {:ok, parsed} = parse("?date=2021-05-05")+ assert %ParsedQueryParams{relative_date: ~D[2021-05-05]} = parsed+ end++ test "errors when invalid date" do+ {:error, :invalid_date} = parse("?date=2021-13-32")+ end+ end++ describe "with_imported -> include.imports" do+ test "true -> true" do+ {:ok, parsed} = parse("?with_imported=true")+ assert %ParsedQueryParams{include: %{imports: true}} = parsed+ end++ test "invalid -> true" do+ {:ok, parsed} = parse("?with_imported=foo")+ assert %ParsedQueryParams{include: %{imports: true}} = parsed+ end++ test "false -> false" do+ {:ok, parsed} = parse("?with_imported=false")+ assert %ParsedQueryParams{include: %{imports: false}} = parsed+ end+ end++ describe "filters" do+ test "parses valid filters" do+ {:ok, parsed} =+ parse("?f=is,exit_page,/:dashboard&f=is,source,Bing&f=is,props:theme,system")++ assert %ParsedQueryParams{+ filters: [+ [:is, "visit:exit_page", ["/:dashboard"]],+ [:is, "visit:source", ["Bing"]],+ [:is, "event:props:theme", ["system"]]+ ]+ } = parsed+ end++ test "errors when filter decoding fails" do+ assert {:error, :invalid_filters} = parse("?f=is,page,/&f=what")+ end+ end+enddiff --git a/test/plausible/stats/query/dashboard_query_serializer_test.exs b/test/plausible/stats/query/dashboard_query_serializer_test.exsnew file mode 100644index 0000000000..8a44861653--- /dev/null+++ b/test/plausible/stats/query/dashboard_query_serializer_test.exs@@ -0,0 +1,95 @@+defmodule Plausible.Stats.DashboardQuerySerializerTest do+ use Plausible.DataCase+ import Plausible.Stats.{DashboardQuerySerializer, DashboardQueryParser}+ alias Plausible.Stats.ParsedQueryParams++ describe "parse -> serialize is a reversible transformation" do+ for query_string <- ["", "date=2021-07-07&f=is,browser,Chrome,Firefox&period=day"] do+ test "with query string being '#{query_string}'" do+ {:ok, parsed} = parse(unquote(query_string))+ assert serialize(parsed) == unquote(query_string)+ end+ end++ test "but alphabetical ordering by key is enforced" do+ {:ok, parsed} = parse("period=day&date=2021-07-07")+ assert serialize(parsed) == "date=2021-07-07&period=day"+ end++ test "but redundant values get removed" do+ {:ok, parsed} = parse("with_imported=true")+ assert serialize(parsed) == ""+ end++ test "but leading ? gets removed" do+ {:ok, parsed} = parse("?period=day")+ assert serialize(parsed) == "period=day"+ end+ end++ describe "input_date_range -> period (+ from, to)" do+ for input_date_range <- [:realtime, :day, :month, :year, :all] do+ test "serializes #{input_date_range} input_date_range" do+ serialized = serialize(%ParsedQueryParams{input_date_range: unquote(input_date_range)})+ assert serialized == "period=#{Atom.to_string(unquote(input_date_range))}"+ end+ end++ for i <- [7, 28, 30, 91] do+ test "serializes {:last_n_days, #{i}} input_date_range" do+ serialized = serialize(%ParsedQueryParams{input_date_range: {:last_n_days, unquote(i)}})+ assert serialized == "period=#{unquote(i)}d"+ end+ end++ for i <- [6, 12] do+ test "serializes {:last_n_months, #{i}} input_date_range" do+ serialized = serialize(%ParsedQueryParams{input_date_range: {:last_n_months, unquote(i)}})+ assert serialized == "period=#{unquote(i)}mo"+ end+ end++ test "serlializes custom input_date_range" do+ serialized =+ serialize(%ParsedQueryParams{+ input_date_range: {:date_range, ~D[2021-01-01], ~D[2021-03-05]}+ })++ assert serialized == "from=2021-01-01&period=custom&to=2021-03-05"+ end+ end++ describe "relative_date -> date" do+ test "serializes a date struct into iso8601" do+ serialized = serialize(%ParsedQueryParams{relative_date: ~D[2021-05-05]})+ assert serialized == "date=2021-05-05"+ end+ end++ describe "include.imports -> with_imported" do+ test "false -> false" do+ serialized = serialize(%ParsedQueryParams{include: %{default_include() | imports: false}})+ assert serialized == "with_imported=false"+ end+ end++ describe "filters" do+ test "serializes multiple filters" do+ serialized =+ serialize(%ParsedQueryParams{+ filters: [+ [:is, "visit:exit_page", ["/:dashboard"]],+ [:is, "visit:source", ["Bing"]],+ [:is, "event:props:theme", ["system"]]+ ]+ })++ assert serialized == "f=is,exit_page,/:dashboard&f=is,source,Bing&f=is,props:theme,system"+ end++ test "serializes empty filters" do+ serialized = serialize(%ParsedQueryParams{filters: []})+ assert serialized == ""+ end+ end+enddiff --git a/test/plausible/stats/query/query_optimizer_test.exs b/test/plausible/stats/query/query_optimizer_test.exsindex d483a4f05c..a4684ef5b3 100644--- a/test/plausible/stats/query/query_optimizer_test.exs+++ b/test/plausible/stats/query/query_optimizer_test.exs@@ -1,7 +1,7 @@defmodule Plausible.Stats.Query.QueryOptimizerTest douse Plausible.DataCase, async: true- alias Plausible.Stats.{Query, QueryOptimizer, DateTimeRange, ParsedQueryParams}+ alias Plausible.Stats.{Query, QueryOptimizer, DateTimeRange, ApiQueryParser}@default_params %{metrics: [:visitors]}@@ -163,7 +163,7 @@ defmodule Plausible.Stats.Query.QueryOptimizerTest doinput_date_range: :month,now: now,timezone: "UTC",- include: Map.put(ParsedQueryParams.default_include(), :trim_relative_date_range, true)+ include: Map.put(ApiQueryParser.default_include(), :trim_relative_date_range, true)})assert result.utc_time_range.first == ~U[2024-01-01 00:00:00Z]@@ -179,7 +179,7 @@ defmodule Plausible.Stats.Query.QueryOptimizerTest doinput_date_range: :year,now: now,timezone: "UTC",- include: Map.put(ParsedQueryParams.default_include(), :trim_relative_date_range, true)+ include: Map.put(ApiQueryParser.default_include(), :trim_relative_date_range, true)})assert result.utc_time_range.first == ~U[2024-01-01 00:00:00Z]@@ -195,7 +195,7 @@ defmodule Plausible.Stats.Query.QueryOptimizerTest doinput_date_range: :day,now: now,timezone: "UTC",- include: Map.put(ParsedQueryParams.default_include(), :trim_relative_date_range, true)+ include: Map.put(ApiQueryParser.default_include(), :trim_relative_date_range, true)})assert result.utc_time_range.first == ~U[2024-01-15 00:00:00Z]@@ -212,7 +212,7 @@ defmodule Plausible.Stats.Query.QueryOptimizerTest doinput_date_range: :month,now: now,timezone: "UTC",- include: Map.put(ParsedQueryParams.default_include(), :trim_relative_date_range, true)+ include: Map.put(ApiQueryParser.default_include(), :trim_relative_date_range, true)})assert result.utc_time_range == original_range@@ -228,7 +228,7 @@ defmodule Plausible.Stats.Query.QueryOptimizerTest doinput_date_range: :year,now: now,timezone: "UTC",- include: Map.put(ParsedQueryParams.default_include(), :trim_relative_date_range, true)+ include: Map.put(ApiQueryParser.default_include(), :trim_relative_date_range, true)})assert result.utc_time_range == original_range@@ -244,7 +244,7 @@ defmodule Plausible.Stats.Query.QueryOptimizerTest doinput_date_range: :day,now: now,timezone: "UTC",- include: Map.put(ParsedQueryParams.default_include(), :trim_relative_date_range, true)+ include: Map.put(ApiQueryParser.default_include(), :trim_relative_date_range, true)})assert result.utc_time_range == original_range@@ -262,7 +262,7 @@ defmodule Plausible.Stats.Query.QueryOptimizerTest dotimezone: "UTC",include:Map.merge(- ParsedQueryParams.default_include(),+ ApiQueryParser.default_include(),%{comparisons: %{mode: "previous_period"}, trim_relative_date_range: true})})@@ -281,7 +281,7 @@ defmodule Plausible.Stats.Query.QueryOptimizerTest dotimezone: "UTC",include:Map.merge(- ParsedQueryParams.default_include(),+ ApiQueryParser.default_include(),%{comparisons: %{mode: "previous_period"}, trim_relative_date_range: true})})@@ -300,7 +300,7 @@ defmodule Plausible.Stats.Query.QueryOptimizerTest doinput_date_range: :month,now: now,timezone: "UTC",- include: Map.put(ParsedQueryParams.default_include(), :trim_relative_date_range, false)+ include: Map.put(ApiQueryParser.default_include(), :trim_relative_date_range, false)})assert result.utc_time_range == original_range@@ -316,7 +316,7 @@ defmodule Plausible.Stats.Query.QueryOptimizerTest doinput_date_range: :month,now: now,timezone: "UTC",- include: ParsedQueryParams.default_include()+ include: ApiQueryParser.default_include()})assert result.utc_time_range == original_range@@ -333,7 +333,7 @@ defmodule Plausible.Stats.Query.QueryOptimizerTest doinput_date_range: {:last_n_days, 7},now: now,timezone: "UTC",- include: Map.put(ParsedQueryParams.default_include(), :trim_relative_date_range, true)+ include: Map.put(ApiQueryParser.default_include(), :trim_relative_date_range, true)})assert result.utc_time_range == original_range@@ -350,7 +350,7 @@ defmodule Plausible.Stats.Query.QueryOptimizerTest doinput_date_range: :year,now: now,timezone: "America/New_York",- include: Map.put(ParsedQueryParams.default_include(), :trim_relative_date_range, true)+ include: Map.put(ApiQueryParser.default_include(), :trim_relative_date_range, true)})nyc_mar_15_end =