Skip to content

Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.

DashboardQueryParser & DashboardQuerySerializer (#5938)

RobertJoonasd6673fbbd510
diff --git a/assets/js/dashboard/util/url-search-params.ts b/assets/js/dashboard/util/url-search-params.ts
index 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.ex
index 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 do
alias 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 do
parse_list(filters, &parse_filter/1)
end
- def parse_filters(nil), do: {:ok, nil}
+ def parse_filters(nil), do: {:ok, []}
defp parse_filter(filter) do
with {: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) do
parse_list(order_by, &parse_order_by_entry/1)
@@ -261,17 +275,18 @@ defmodule Plausible.Stats.ApiQueryParser do
defp 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)}
end
end
- 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) do
expected_keys =
- Plausible.Stats.ParsedQueryParams.default_include()
+ @default_include
|> Map.keys()
|> Enum.map(&Atom.to_string/1)
@@ -291,11 +306,10 @@ defmodule Plausible.Stats.ApiQueryParser do
defp 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) do
Map.new(map, fn {key, value} ->
diff --git a/lib/plausible/stats/dashboard_query_parser.ex b/lib/plausible/stats/dashboard_query_parser.ex
new file mode 100644
index 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
+end
diff --git a/lib/plausible/stats/dashboard_query_serializer.ex b/lib/plausible/stats/dashboard_query_serializer.ex
new file mode 100644
index 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
+end
diff --git a/lib/plausible/stats/legacy/legacy_query_builder.ex b/lib/plausible/stats/legacy/legacy_query_builder.ex
index 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) do
include =
@@ -296,7 +296,7 @@ defmodule Plausible.Stats.Legacy.QueryBuilder do
_ -> %{}
end
- Plausible.Stats.ParsedQueryParams.default_include()
+ Plausible.Stats.ApiQueryParser.default_include()
|> Map.merge(include)
end
diff --git a/lib/plausible/stats/parsed_query_params.ex b/lib/plausible/stats/parsed_query_params.ex
index 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 false
defstruct [
- :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))
end
end
diff --git a/lib/plausible/stats/query.ex b/lib/plausible/stats/query.ex
index f628e33ea1..e6482e050e 100644
--- a/lib/plausible/stats/query.ex
+++ b/lib/plausible/stats/query.ex
@@ -18,7 +18,7 @@ defmodule Plausible.Stats.Query do
timezone: 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 metadata
diff --git a/lib/plausible/stats/query_builder.ex b/lib/plausible/stats/query_builder.ex
index 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 do
end
end
- 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] do
duration_minutes =
case input_date_range do
@@ -68,50 +68,44 @@ defmodule Plausible.Stats.QueryBuilder do
DateTimeRange.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) do
DateTimeRange.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) do
DateTimeRange.new!(from, to)
end
@@ -120,7 +114,7 @@ defmodule Plausible.Stats.QueryBuilder do
parsed_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 do
end
defp 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 do
parsed_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 do
consolidated_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
+ )
end
on_ee do
diff --git a/test/plausible/stats/query/query_parser_test.exs b/test/plausible/stats/query/api_query_parser_test.exs
similarity index 100%
rename from test/plausible/stats/query/query_parser_test.exs
rename to test/plausible/stats/query/api_query_parser_test.exs
diff --git a/test/plausible/stats/query/dashboard_query_parser_test.exs b/test/plausible/stats/query/dashboard_query_parser_test.exs
new file mode 100644
index 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
+end
diff --git a/test/plausible/stats/query/dashboard_query_serializer_test.exs b/test/plausible/stats/query/dashboard_query_serializer_test.exs
new file mode 100644
index 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
+end
diff --git a/test/plausible/stats/query/query_optimizer_test.exs b/test/plausible/stats/query/query_optimizer_test.exs
index 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 do
use 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 do
input_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 do
input_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 do
input_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 do
input_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 do
input_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 do
input_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 do
timezone: "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 do
timezone: "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 do
input_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 do
input_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 do
input_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 do
input_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 =