Skip to content

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

Remove internal query api schema (#5969)

RobertJoonas96482960de25
diff --git a/assets/js/types/query-api.d.ts b/assets/js/types/query-api.d.ts
index 4ccee9bb28..5778384cb5 100644
--- a/assets/js/types/query-api.d.ts
+++ b/assets/js/types/query-api.d.ts
@@ -12,13 +12,10 @@ export type Metric =
| "conversion_rate"
| "group_conversion_rate"
| "time_on_page"
- | "exit_rate"
| "total_revenue"
| "average_revenue"
| "scroll_depth";
export type DateRangeShorthand =
- | "30m"
- | "realtime"
| "all"
| "day"
| "7d"
@@ -71,7 +68,7 @@ export type SimpleFilterDimensions =
| "visit:exit_page_hostname";
export type CustomPropertyFilterDimensions = string;
export type GoalDimension = "event:goal";
-export type TimeDimensions = ("time" | "time:month" | "time:week" | "time:day" | "time:hour") | "time:minute";
+export type TimeDimensions = "time" | "time:month" | "time:week" | "time:day" | "time:hour";
export type FilterTree = FilterEntry | FilterAndOr | FilterNot | FilterHasDone;
export type FilterEntry = FilterWithoutGoals | FilterWithIs | FilterWithContains | FilterWithPattern;
/**
@@ -126,7 +123,7 @@ export type FilterWithContains =
* @maxItems 3
*/
export type FilterWithPattern = [
- FilterOperationRegex | ("matches_wildcard" | "matches_wildcard_not"),
+ FilterOperationRegex,
SimpleFilterDimensions | CustomPropertyFilterDimensions,
Clauses
];
@@ -157,7 +154,6 @@ export type OrderByEntry = [
Metric | SimpleFilterDimensions | CustomPropertyFilterDimensions | TimeDimensions,
"asc" | "desc"
];
-export type ComparisonMode = "previous_period" | "year_over_year";
export interface QueryApiSchema {
/**
@@ -170,7 +166,6 @@ export interface QueryApiSchema {
* @minItems 1
*/
metrics: [Metric, ...Metric[]];
- date?: string;
/**
* Date range to query
*/
@@ -198,14 +193,6 @@ export interface QueryApiSchema {
* If set and using `day`, `month` or `year` date_ranges, the query will be trimmed to the current date
*/
trim_relative_date_range?: boolean;
- /**
- * If set, executes the same query but over a comparison date range
- */
- compare?: DateRange | ComparisonMode | never;
- /**
- * With the `compare` option, if set and using time:day dimensions, day-of-week of comparison query is matched
- */
- compare_match_day_of_week?: boolean;
};
pagination?: {
/**
diff --git a/extra/lib/plausible/stats/consolidated_view.ex b/extra/lib/plausible/stats/consolidated_view.ex
index 6e42871c75..8b646ae11d 100644
--- a/extra/lib/plausible/stats/consolidated_view.ex
+++ b/extra/lib/plausible/stats/consolidated_view.ex
@@ -86,25 +86,16 @@ defmodule Plausible.Stats.ConsolidatedView do
end
defp query_24h_intervals(view, now) do
+ from_datetime = now |> NaiveDateTime.shift(hour: -24) |> DateTime.from_naive!("Etc/UTC")
+ to_datetime = now |> DateTime.from_naive!("Etc/UTC")
+
graph_query =
- Stats.Query.parse_and_build!(
- view,
- :internal,
- %{
- "site_id" => view.domain,
- "metrics" => ["visitors"],
- "date_range" => [
- NaiveDateTime.shift(now, hour: -24)
- |> DateTime.from_naive!("Etc/UTC")
- |> DateTime.to_iso8601(),
- now
- |> DateTime.from_naive!("Etc/UTC")
- |> DateTime.to_iso8601()
- ],
- "dimensions" => ["time:hour"],
- "order_by" => [["time:hour", "asc"]]
- }
- )
+ QueryBuilder.build!(view, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: {:datetime_range, from_datetime, to_datetime},
+ dimensions: ["time:hour"],
+ order_by: [{"time:hour", :asc}]
+ })
%Stats.QueryResult{results: results} = Stats.query(view, graph_query)
diff --git a/extra/lib/plausible_web/live/funnel_settings/form.ex b/extra/lib/plausible_web/live/funnel_settings/form.ex
index 3ad7dc71d5..2dbeb46051 100644
--- a/extra/lib/plausible_web/live/funnel_settings/form.ex
+++ b/extra/lib/plausible_web/live/funnel_settings/form.ex
@@ -10,6 +10,7 @@ defmodule PlausibleWeb.Live.FunnelSettings.Form do
import PlausibleWeb.Live.Components.Form
alias Plausible.{Goals, Funnels}
+ alias Plausible.Stats.{QueryBuilder, ParsedQueryParams}
def mount(_params, %{"domain" => domain} = session, socket) do
site =
@@ -349,15 +350,10 @@ defmodule PlausibleWeb.Live.FunnelSettings.Form do
)
query =
- Plausible.Stats.Query.parse_and_build!(
- site,
- :internal,
- %{
- "site_id" => site.domain,
- "date_range" => "month",
- "metrics" => ["pageviews"]
- }
- )
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:pageviews],
+ input_date_range: :month
+ })
{:ok, {definition, query}}
end
diff --git a/lib/plausible/segments/segment.ex b/lib/plausible/segments/segment.ex
index 5a6520d683..0f7ef3916e 100644
--- a/lib/plausible/segments/segment.ex
+++ b/lib/plausible/segments/segment.ex
@@ -5,6 +5,7 @@ defmodule Plausible.Segments.Segment do
use Plausible
use Ecto.Schema
import Ecto.Changeset
+ alias Plausible.Stats.{ApiQueryParser, QueryBuilder, ParsedQueryParams}
@segment_types [:personal, :site]
@@ -102,77 +103,33 @@ defmodule Plausible.Segments.Segment do
),
do: :ok
- def validate_segment_data_if_exists(%Plausible.Site{} = site, segment_data, restricted_depth?),
- do: validate_segment_data(site, segment_data, restricted_depth?)
-
- def validate_segment_data(
- %Plausible.Site{} = site,
- %{"filters" => filters},
- restricted_depth?
- ) do
- with {:ok, %Plausible.Stats.Query{filters: parsed_filters}} <-
- build_naive_query_from_segment_data(site, filters),
- :ok <- maybe_validate_filters_depth(parsed_filters, restricted_depth?) do
- :ok
- else
- {:error, message} ->
- reformat_filters_errors(message)
-
- :error_deep_filters_not_supported ->
- reformat_filters_errors("Invalid filters. Deep filters are not supported.")
- end
+ def validate_segment_data_if_exists(%Plausible.Site{} = site, segment_data, restricted_depth?) do
+ validate_segment_data(site, segment_data, restricted_depth?)
end
+ @spec validate_segment_data(Plausible.Site.t(), map(), boolean()) ::
+ :ok | {:error, {:invalid_filters, String.t()}}
@doc """
- This function builds a simple query using the filters from Plausibe.Segment.segment_data
- to test whether the filters used in the segment stand as legitimate query filters.
- If they don't, it indicates an error with the filters that must be passed to the client,
- so they could reconfigure the filters.
+ Checks whether the filters in segment_data are valid by attempting to build
+ a `%Query{}` struct with them. The `metrics` and `input_date_range` values
+ do not matter as long as they don't affect filters being the only field
+ affecting query validity.
"""
- def build_naive_query_from_segment_data(%Plausible.Site{} = site, filters),
- do:
- Plausible.Stats.Query.parse_and_build(
- site,
- :internal,
- %{
- "site_id" => site.domain,
- "metrics" => ["visitors"],
- "date_range" => "7d",
- "filters" => filters
- },
- %{}
- )
-
- @doc """
- This function handles the error from building the naive query that is used to validate segment filters.
- If the error is only about filters, it's marked as :invalid_filters error and ultimately forwarded to client.
- If the error is not only about filters, the client can't do anything about the situation,
- and the error message is returned as-is.
-
- ### Examples
- iex> reformat_filters_errors(~s(#/metrics/0 Invalid metric "Visitors"\\n#/filters/0 Invalid filter "A"))
- {:error, ~s(#/metrics/0 Invalid metric "Visitors"\\n#/filters/0 Invalid filter "A")}
-
- iex> reformat_filters_errors(~s(#/filters/0 Invalid filter "A"\\n#/filters/1 Invalid filter "B"))
- {:error, {:invalid_filters, ~s(#/filters/0 Invalid filter "A"\\n#/filters/1 Invalid filter "B")}}
-
- iex> reformat_filters_errors("Invalid filters. Dimension `event:goal` can only be filtered at the top level.")
- {:error, {:invalid_filters, "Invalid filters. Dimension `event:goal` can only be filtered at the top level."}}
- """
- def reformat_filters_errors(message) do
- lines = String.split(message, "\n")
-
- if Enum.all?(lines, fn line ->
- String.starts_with?(line, "#/filters/") or String.starts_with?(line, "Invalid filters.")
- end) do
- {:error, {:invalid_filters, message}}
+ def validate_segment_data(%Plausible.Site{} = site, %{"filters" => filters}, restricted_depth?) do
+ with {:ok, parsed_filters} <- ApiQueryParser.parse_filters(filters),
+ {:ok, _} <-
+ QueryBuilder.build(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: {:last_n_days, 7},
+ filters: parsed_filters
+ }),
+ :ok <- maybe_validate_filters_depth(parsed_filters, restricted_depth?) do
+ :ok
else
- {:error, message}
+ {:error, message} -> {:error, {:invalid_filters, message}}
end
end
- @spec maybe_validate_filters_depth([any()], boolean()) ::
- :ok | :error_deep_filters_not_supported
defp maybe_validate_filters_depth(filters, restricted_depth?)
defp maybe_validate_filters_depth(_filters, false), do: :ok
@@ -181,7 +138,7 @@ defmodule Plausible.Segments.Segment do
if Enum.all?(filters, &dashboard_compatible_filter?/1) do
:ok
else
- :error_deep_filters_not_supported
+ {:error, "Invalid filters. Deep filters are not supported."}
end
end
diff --git a/lib/plausible/stats/api_query_parser.ex b/lib/plausible/stats/api_query_parser.ex
index e7d4736f21..7023cd3541 100644
--- a/lib/plausible/stats/api_query_parser.ex
+++ b/lib/plausible/stats/api_query_parser.ex
@@ -22,11 +22,9 @@ defmodule Plausible.Stats.ApiQueryParser do
def default_pagination(), do: @default_pagination
- def parse(schema_type, params) when is_map(params) do
- input_date_range = Map.get(params, "date_range")
-
- with :ok <- JSONSchema.validate(schema_type, params),
- {:ok, input_date_range} <- parse_input_date_range(input_date_range),
+ def parse(params) when is_map(params) do
+ with :ok <- JSONSchema.validate(params),
+ {:ok, input_date_range} <- parse_input_date_range(params["date_range"]),
{:ok, metrics} <- parse_metrics(Map.fetch!(params, "metrics")),
{:ok, filters} <- parse_filters(params["filters"]),
{:ok, dimensions} <- parse_dimensions(params["dimensions"]),
@@ -96,7 +94,7 @@ defmodule Plausible.Stats.ApiQueryParser do
def parse_filter_second(_operator, filter), do: parse_filter_dimension(filter)
defp parse_filter_dimension([_operator, filter_dimension | _rest] = filter) do
- parse_filter_dimension_string(filter_dimension, "Invalid filter '#{i(filter)}")
+ parse_filter_dimension_string(filter_dimension, "Invalid filter '#{i(filter)}'.")
end
defp parse_filter_dimension(filter), do: {:error, "Invalid filter '#{i(filter)}'."}
@@ -149,7 +147,7 @@ defmodule Plausible.Stats.ApiQueryParser do
end
end
- defp parse_clauses_list(filter), do: {:error, "Invalid filter '#{i(filter)}'"}
+ defp parse_clauses_list(filter), do: {:error, "Invalid filter '#{i(filter)}'."}
defp parse_filter_modifiers(modifiers) when is_map(modifiers) do
{:ok, [atomize_keys(modifiers)]}
@@ -159,8 +157,6 @@ defmodule Plausible.Stats.ApiQueryParser do
{:ok, []}
end
- defp parse_input_date_range("realtime"), do: {:ok, :realtime}
- defp parse_input_date_range("30m"), do: {:ok, :realtime_30m}
defp parse_input_date_range("day"), do: {:ok, :day}
defp parse_input_date_range("month"), do: {:ok, :month}
defp parse_input_date_range("year"), do: {:ok, :year}
@@ -280,24 +276,12 @@ defmodule Plausible.Stats.ApiQueryParser do
@allowed_include_keys Enum.map(Map.keys(@default_include), &Atom.to_string/1)
- defp parse_include_entry("compare", value) do
- with {:ok, parsed_compare} <- parse_compare(value) do
- {:ok, {:compare, parsed_compare}}
- end
- end
-
defp parse_include_entry(key, value) when key in @allowed_include_keys do
{:ok, {String.to_existing_atom(key), value}}
end
defp parse_include_entry(key, _value), do: {:error, "Invalid include key'#{i(key)}'."}
- defp parse_compare(false), do: {:ok, nil}
- defp parse_compare("previous_period"), do: {:ok, :previous_period}
- defp parse_compare("year_over_year"), do: {:ok, :year_over_year}
- defp parse_compare([from_date, to_date]), do: parse_date_strings(from_date, to_date)
- defp parse_compare(compare), do: {:error, "Invalid include.compare '#{i(compare)}'."}
-
defp parse_pagination(pagination) when is_map(pagination) do
{:ok, Map.merge(@default_pagination, atomize_keys(pagination))}
end
@@ -306,13 +290,10 @@ defmodule Plausible.Stats.ApiQueryParser do
defp atomize_keys(map) when is_map(map) do
Map.new(map, fn {key, value} ->
- key = String.to_existing_atom(key)
- {key, atomize_keys(value)}
+ {String.to_existing_atom(key), value}
end)
end
- defp atomize_keys(value), do: value
-
defp parse_filter_dimension_string(dimension, error_message \\ "") do
case dimension do
"event:props:" <> property_name ->
diff --git a/lib/plausible/stats/goal_suggestions.ex b/lib/plausible/stats/goal_suggestions.ex
index 2e93e2e67b..17438804f7 100644
--- a/lib/plausible/stats/goal_suggestions.ex
+++ b/lib/plausible/stats/goal_suggestions.ex
@@ -2,7 +2,7 @@ defmodule Plausible.Stats.GoalSuggestions do
@moduledoc false
alias Plausible.{Repo, ClickhouseRepo}
- alias Plausible.Stats.Query
+ alias Plausible.Stats.{Query, QueryBuilder, ParsedQueryParams, QueryInclude}
import Plausible.Stats.Base
import Ecto.Query
@@ -39,16 +39,11 @@ defmodule Plausible.Stats.GoalSuggestions do
from_date = Date.shift(to_date, month: -6)
query =
- Plausible.Stats.Query.parse_and_build!(
- site,
- :internal,
- %{
- "site_id" => site.domain,
- "date_range" => [Date.to_iso8601(from_date), Date.to_iso8601(to_date)],
- "metrics" => ["pageviews"],
- "include" => %{"imports" => true}
- }
- )
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ input_date_range: {:date_range, from_date, to_date},
+ metrics: [:pageviews],
+ include: %QueryInclude{imports: true}
+ })
native_q =
from(e in base_event_query(query),
diff --git a/lib/plausible/stats/json_schema.ex b/lib/plausible/stats/json_schema.ex
index 4ba428780e..8b4f482d0a 100644
--- a/lib/plausible/stats/json_schema.ex
+++ b/lib/plausible/stats/json_schema.ex
@@ -8,36 +8,31 @@ defmodule Plausible.Stats.JSONSchema do
use Plausible
alias Plausible.Stats.JSONSchema.Utils
- @external_resource "priv/json-schemas/query-api-schema.json"
+ @json_schema_filepath "priv/json-schemas/query-api-schema.json"
+ @external_resource @json_schema_filepath
- @raw_internal_schema Application.app_dir(:plausible, "priv/json-schemas/query-api-schema.json")
- |> File.read!()
- |> Jason.decode!()
- @raw_public_schema Utils.traverse(@raw_internal_schema, fn
- %{"$comment" => "only :internal"} ->
- :remove
+ @raw_schema Application.app_dir(:plausible, @json_schema_filepath)
+ |> File.read!()
+ |> Jason.decode!()
+ |> Utils.traverse(fn
+ %{"$comment" => "only :ee"} = value ->
+ if(ee?(), do: Map.delete(value, "$comment"), else: :remove)
- %{"$comment" => "only :ee"} = value ->
- if(ee?(), do: Map.delete(value, "$comment"), else: :remove)
+ value ->
+ value
+ end)
- value ->
- value
- end)
- @internal_query_schema ExJsonSchema.Schema.resolve(@raw_internal_schema)
- @public_query_schema ExJsonSchema.Schema.resolve(@raw_public_schema)
+ def raw_schema(), do: @raw_schema
- def validate(schema_type, params) do
- case ExJsonSchema.Validator.validate(schema(schema_type), params) do
+ @query_schema ExJsonSchema.Schema.resolve(@raw_schema)
+
+ def validate(params) do
+ case ExJsonSchema.Validator.validate(@query_schema, params) do
:ok -> :ok
{:error, errors} -> {:error, format_errors(errors, params)}
end
end
- def raw_public_schema(), do: @raw_public_schema
-
- defp schema(:public), do: @public_query_schema
- defp schema(:internal), do: @internal_query_schema
-
defp format_errors(errors, params) do
errors
|> Enum.map_join("\n", fn {error, path} ->
diff --git a/lib/plausible/stats/query.ex b/lib/plausible/stats/query.ex
index 8b0fbe409e..63ca541d37 100644
--- a/lib/plausible/stats/query.ex
+++ b/lib/plausible/stats/query.ex
@@ -49,25 +49,25 @@ defmodule Plausible.Stats.Query do
def parse_and_build(
%Plausible.Site{domain: domain} = site,
- schema_type,
%{"site_id" => domain} = params,
debug_metadata \\ %{}
) do
with {:ok, %ParsedQueryParams{} = parsed_query_params} <-
- ApiQueryParser.parse(schema_type, params) do
+ ApiQueryParser.parse(params) do
QueryBuilder.build(site, parsed_query_params, debug_metadata)
end
end
- def parse_and_build!(site, schema_type, params, debug_metadata \\ %{}) do
- case parse_and_build(site, schema_type, params, debug_metadata) do
+ def parse_and_build!(site, params, debug_metadata \\ %{}) do
+ case parse_and_build(site, params, debug_metadata) do
{:ok, query} -> query
{:error, reason} -> raise "Failed to build query: #{inspect(reason)}"
end
end
@doc """
- Builds query from old-style stats APIv1 params. New code should use `Query.parse_and_build`.
+ Builds query from old-style stats APIv1 params. New code should use `Query.parse_and_build`
+ or `QueryBuilder.build` with already parsed params.
"""
def from(site, params, debug_metadata \\ %{}, now \\ nil) do
Legacy.QueryBuilder.from(site, params, debug_metadata, now)
diff --git a/lib/plausible/stats/query_builder.ex b/lib/plausible/stats/query_builder.ex
index f98195ef0f..6a9bf949be 100644
--- a/lib/plausible/stats/query_builder.ex
+++ b/lib/plausible/stats/query_builder.ex
@@ -21,6 +21,7 @@ defmodule Plausible.Stats.QueryBuilder do
query = do_build(parsed_query_params, site, debug_metadata),
:ok <- validate_order_by(query),
:ok <- validate_custom_props_access(site, query),
+ :ok <- validate_case_sensitive_filter_modifier(query),
:ok <- validate_toplevel_only_filter_dimension(query),
:ok <- validate_special_metrics_filters(query),
:ok <- validate_behavioral_filters(query),
@@ -45,6 +46,13 @@ defmodule Plausible.Stats.QueryBuilder do
end
end
+ def build!(site, parsed_query_params, debug_metadata \\ %{}) do
+ case build(site, parsed_query_params, debug_metadata) do
+ {:ok, query} -> query
+ {:error, reason} -> raise "Failed to build query: #{inspect(reason)}"
+ end
+ end
+
defp resolve_segments_in_filters(%ParsedQueryParams{} = parsed_query_params, site) do
with {:ok, preloaded_segments} <-
Segments.Filters.preload_needed_segments(site, parsed_query_params.filters),
@@ -235,6 +243,29 @@ defmodule Plausible.Stats.QueryBuilder do
end
end
+ @pattern_filter_operators [:matches, :matches_not, :matches_wildcard, :matches_wildcard_not]
+ defp validate_case_sensitive_filter_modifier(query) do
+ invalid_filter =
+ query.filters
+ |> Filters.all_leaf_filters()
+ |> Enum.find(fn filter ->
+ case filter do
+ [operator, _, _, modifiers] when operator in @pattern_filter_operators ->
+ is_map_key(modifiers, :case_insensitive)
+
+ _ ->
+ false
+ end
+ end)
+
+ if invalid_filter do
+ {:error,
+ "Invalid filters. The case_sensitive modifier is not allowed with pattern operators (#{i(invalid_filter)})"}
+ else
+ :ok
+ end
+ end
+
@only_toplevel ["event:goal", "event:hostname"]
defp validate_toplevel_only_filter_dimension(query) do
not_toplevel =
diff --git a/lib/plausible_web/controllers/api/external_query_api_controller.ex b/lib/plausible_web/controllers/api/external_query_api_controller.ex
index 9a5e9d2341..0d391540c5 100644
--- a/lib/plausible_web/controllers/api/external_query_api_controller.ex
+++ b/lib/plausible_web/controllers/api/external_query_api_controller.ex
@@ -9,7 +9,7 @@ defmodule PlausibleWeb.Api.ExternalQueryApiController do
def query(conn, params) do
site = Repo.preload(conn.assigns.site, :owners)
- case Query.parse_and_build(site, conn.assigns.schema_type, params, debug_metadata(conn)) do
+ case Query.parse_and_build(site, params, debug_metadata(conn)) do
{:ok, query} ->
results = Plausible.Stats.query(site, query)
json(conn, results)
@@ -22,6 +22,6 @@ defmodule PlausibleWeb.Api.ExternalQueryApiController do
end
def schema(conn, _params) do
- json(conn, Plausible.Stats.JSONSchema.raw_public_schema())
+ json(conn, Plausible.Stats.JSONSchema.raw_schema())
end
end
diff --git a/lib/plausible_web/live/goal_settings/form.ex b/lib/plausible_web/live/goal_settings/form.ex
index 10456cac53..321e2947f6 100644
--- a/lib/plausible_web/live/goal_settings/form.ex
+++ b/lib/plausible_web/live/goal_settings/form.ex
@@ -7,6 +7,7 @@ defmodule PlausibleWeb.Live.GoalSettings.Form do
alias PlausibleWeb.Live.Components.ComboBox
alias Plausible.Repo
+ alias Plausible.Stats.{QueryBuilder, ParsedQueryParams, QueryInclude}
def update(assigns, socket) do
site = Repo.preload(assigns.site, [:team, :owners])
@@ -506,16 +507,11 @@ defmodule PlausibleWeb.Live.GoalSettings.Form do
def suggest_page_paths(input, site) do
query =
- Plausible.Stats.Query.parse_and_build!(
- site,
- :internal,
- %{
- "site_id" => site.domain,
- "date_range" => "all",
- "metrics" => ["pageviews"],
- "include" => %{"imports" => true}
- }
- )
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ input_date_range: :all,
+ metrics: [:pageviews],
+ include: %QueryInclude{imports: true}
+ })
site
|> Plausible.Stats.filter_suggestions(query, "page", input)
diff --git a/lib/plausible_web/live/shields/hostname_rules.ex b/lib/plausible_web/live/shields/hostname_rules.ex
index 37dd1559fb..6bc6880ab4 100644
--- a/lib/plausible_web/live/shields/hostname_rules.ex
+++ b/lib/plausible_web/live/shields/hostname_rules.ex
@@ -8,6 +8,7 @@ defmodule PlausibleWeb.Live.Shields.HostnameRules do
alias PlausibleWeb.Live.Components.Modal
alias Plausible.Shields
alias Plausible.Shield
+ alias Plausible.Stats.{QueryBuilder, ParsedQueryParams}
def update(assigns, socket) do
socket =
@@ -252,15 +253,10 @@ defmodule PlausibleWeb.Live.Shields.HostnameRules do
def suggest_hostnames(input, _options, site) do
query =
- Plausible.Stats.Query.parse_and_build!(
- site,
- :internal,
- %{
- "site_id" => site.domain,
- "date_range" => "all",
- "metrics" => ["pageviews"]
- }
- )
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ input_date_range: :all,
+ metrics: [:pageviews]
+ })
site
|> Plausible.Stats.filter_suggestions(query, "hostname", input)
diff --git a/lib/plausible_web/live/shields/page_rules.ex b/lib/plausible_web/live/shields/page_rules.ex
index b0df6e789e..e6c78cf1b3 100644
--- a/lib/plausible_web/live/shields/page_rules.ex
+++ b/lib/plausible_web/live/shields/page_rules.ex
@@ -8,6 +8,7 @@ defmodule PlausibleWeb.Live.Shields.PageRules do
alias PlausibleWeb.Live.Components.Modal
alias Plausible.Shields
alias Plausible.Shield
+ alias Plausible.Stats.{QueryBuilder, ParsedQueryParams}
def update(assigns, socket) do
socket =
@@ -248,16 +249,11 @@ defmodule PlausibleWeb.Live.Shields.PageRules do
def suggest_page_paths(input, _options, site, page_rules) do
query =
- Plausible.Stats.Query.parse_and_build!(
- site,
- :internal,
- %{
- "site_id" => site.domain,
- "date_range" => "all",
- "metrics" => ["pageviews"],
- "filters" => [["is_not", "event:page", Enum.map(page_rules, & &1.page_path)]]
- }
- )
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ input_date_range: :all,
+ metrics: [:pageviews],
+ filters: [[:is_not, "event:page", Enum.map(page_rules, & &1.page_path)]]
+ })
site
|> Plausible.Stats.filter_suggestions(query, "page", input)
diff --git a/lib/plausible_web/router.ex b/lib/plausible_web/router.ex
index 4168b8d3d5..ef561ea0f5 100644
--- a/lib/plausible_web/router.ex
+++ b/lib/plausible_web/router.ex
@@ -325,8 +325,7 @@ defmodule PlausibleWeb.Router do
},
assigns: %{
api_scope: "stats:read:*",
- api_context: :site,
- schema_type: :public
+ api_context: :site
} do
pipe_through [:public_api, PlausibleWeb.Plugs.AuthorizePublicAPI]
@@ -336,7 +335,7 @@ defmodule PlausibleWeb.Router do
scope "/api/docs", PlausibleWeb.Api do
get "/query/schema.json", ExternalQueryApiController, :schema
- scope assigns: %{schema_type: :public} do
+ scope [] do
pipe_through :docs_stats_api
post "/query", ExternalQueryApiController, :query
diff --git a/lib/workers/send_email_report.ex b/lib/workers/send_email_report.ex
index 333b0752af..89ce4f6e2f 100644
--- a/lib/workers/send_email_report.ex
+++ b/lib/workers/send_email_report.ex
@@ -3,7 +3,7 @@ defmodule Plausible.Workers.SendEmailReport do
use Plausible.Repo
use Oban.Worker, queue: :send_email_reports, max_attempts: 1
- alias Plausible.Stats.{Query, QueryResult}
+ alias Plausible.Stats.{QueryResult, QueryBuilder, ParsedQueryParams, QueryInclude}
import Ecto.Query, only: [from: 2]
@@ -70,15 +70,16 @@ defmodule Plausible.Workers.SendEmailReport do
defp report_name(@monthly, first), do: Calendar.strftime(first, "%B")
defp stats(site, date_range) do
- date_range = [
- Date.to_iso8601(date_range.first),
- Date.to_iso8601(date_range.last)
- ]
+ shared_params = %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: {:date_range, date_range.first, date_range.last},
+ pagination: %{limit: 5, offset: 0}
+ }
- stats = stats_aggregates(site, date_range)
- pages = pages(site, date_range)
- sources = sources(site, date_range)
- goals = goals(site, date_range)
+ stats = stats_aggregates(site, shared_params)
+ pages = pages(site, shared_params)
+ sources = sources(site, shared_params)
+ goals = goals(site, shared_params)
stats
|> Map.put(:pages, pages)
@@ -86,18 +87,14 @@ defmodule Plausible.Workers.SendEmailReport do
|> Map.put(:goals, goals)
end
- defp stats_aggregates(site, date_range) do
+ defp stats_aggregates(site, %ParsedQueryParams{} = shared_params) do
query =
- Query.parse_and_build!(
+ QueryBuilder.build!(
site,
- :internal,
- %{
- "site_id" => site.domain,
- "metrics" => ["pageviews", "visitors", "bounce_rate"],
- "date_range" => date_range,
- "include" => %{"compare" => "previous_period"},
- "pagination" => %{"limit" => 5}
- }
+ struct!(shared_params,
+ metrics: [:pageviews, :visitors, :bounce_rate],
+ include: %QueryInclude{compare: :previous_period}
+ )
)
%QueryResult{
@@ -118,19 +115,8 @@ defmodule Plausible.Workers.SendEmailReport do
}
end
- defp pages(site, date_range) do
- query =
- Query.parse_and_build!(
- site,
- :internal,
- %{
- "site_id" => site.domain,
- "metrics" => ["visitors"],
- "dimensions" => ["event:page"],
- "date_range" => date_range,
- "pagination" => %{"limit" => 5}
- }
- )
+ defp pages(site, %ParsedQueryParams{} = shared_params) do
+ query = QueryBuilder.build!(site, struct!(shared_params, dimensions: ["event:page"]))
site
|> Plausible.Stats.query(query)
@@ -143,19 +129,14 @@ defmodule Plausible.Workers.SendEmailReport do
end)
end
- defp sources(site, date_range) do
+ defp sources(site, %ParsedQueryParams{} = shared_params) do
query =
- Query.parse_and_build!(
+ QueryBuilder.build!(
site,
- :internal,
- %{
- "site_id" => site.domain,
- "metrics" => ["visitors"],
- "filters" => [["is_not", "visit:source", ["Direct / None"]]],
- "dimensions" => ["visit:source"],
- "date_range" => date_range,
- "pagination" => %{"limit" => 5}
- }
+ struct!(shared_params,
+ dimensions: ["visit:source"],
+ filters: [[:is_not, "visit:source", ["Direct / None"]]]
+ )
)
site
@@ -169,19 +150,8 @@ defmodule Plausible.Workers.SendEmailReport do
end)
end
- defp goals(site, date_range) do
- query =
- Query.parse_and_build!(
- site,
- :internal,
- %{
- "site_id" => site.domain,
- "metrics" => ["visitors"],
- "dimensions" => ["event:goal"],
- "date_range" => date_range,
- "pagination" => %{"limit" => 5}
- }
- )
+ defp goals(site, %ParsedQueryParams{} = shared_params) do
+ query = QueryBuilder.build!(site, struct!(shared_params, dimensions: ["event:goal"]))
site
|> Plausible.Stats.query(query)
diff --git a/lib/workers/traffic_change_notifier.ex b/lib/workers/traffic_change_notifier.ex
index fccab08b5d..b026e02eaa 100644
--- a/lib/workers/traffic_change_notifier.ex
+++ b/lib/workers/traffic_change_notifier.ex
@@ -4,7 +4,7 @@ defmodule Plausible.Workers.TrafficChangeNotifier do
"""
use Plausible
use Plausible.Repo
- alias Plausible.Stats.{Query, Clickhouse}
+ alias Plausible.Stats.{Clickhouse, ParsedQueryParams, QueryBuilder}
alias Plausible.Site.TrafficChangeNotification
alias PlausibleWeb.Router.Helpers, as: Routes
@@ -129,22 +129,20 @@ defmodule Plausible.Workers.TrafficChangeNotifier do
|> put_pages(site)
end
- @base_query_params %{
- "metrics" => ["visitors"],
- "pagination" => %{"limit" => 3},
- "date_range" => "realtime"
+ @base_query_params %ParsedQueryParams{
+ metrics: [:visitors],
+ pagination: %{limit: 3, offset: 0},
+ input_date_range: :realtime
}
defp put_sources(stats, site) do
query =
- Query.parse_and_build!(
+ QueryBuilder.build!(
site,
- :internal,
- Map.merge(@base_query_params, %{
- "site_id" => site.domain,
- "dimensions" => ["visit:source"],
- "filters" => [["is_not", "visit:source", ["Direct / None"]]]
- })
+ struct!(@base_query_params,
+ dimensions: ["visit:source"],
+ filters: [[:is_not, "visit:source", ["Direct / None"]]]
+ )
)
%{results: sources} = Plausible.Stats.query(site, query)
@@ -153,15 +151,7 @@ defmodule Plausible.Workers.TrafficChangeNotifier do
end
defp put_pages(stats, site) do
- query =
- Query.parse_and_build!(
- site,
- :internal,
- Map.merge(@base_query_params, %{
- "site_id" => site.domain,
- "dimensions" => ["event:page"]
- })
- )
+ query = QueryBuilder.build!(site, struct!(@base_query_params, dimensions: ["event:page"]))
%{results: pages} = Plausible.Stats.query(site, query)
diff --git a/priv/json-schemas/query-api-schema.json b/priv/json-schemas/query-api-schema.json
index d9b7dc483a..3d3eb38bd6 100644
--- a/priv/json-schemas/query-api-schema.json
+++ b/priv/json-schemas/query-api-schema.json
@@ -15,10 +15,6 @@
"uniqueItems": true,
"description": "List of metrics to query"
},
- "date": {
- "type": "string",
- "$comment": "only :internal"
- },
"date_range": {
"oneOf": [
{ "$ref": "#/definitions/date_range_shorthand" },
@@ -67,22 +63,6 @@
"type": "boolean",
"default": false,
"description": "If set and using `day`, `month` or `year` date_ranges, the query will be trimmed to the current date"
- },
- "compare": {
- "$comment": "only :internal",
- "oneOf": [
- { "$ref": "#/definitions/date_range" },
- { "$ref": "#/definitions/comparison_mode" },
- false
- ],
- "default": false,
- "description": "If set, executes the same query but over a comparison date range"
- },
- "compare_match_day_of_week": {
- "$comment": "only :internal",
- "type": "boolean",
- "default": false,
- "description": "With the `compare` option, if set and using time:day dimensions, day-of-week of comparison query is matched"
}
}
},
@@ -146,14 +126,6 @@
},
"date_range_shorthand": {
"anyOf": [
- {
- "const": "30m",
- "$comment": "only :internal"
- },
- {
- "const": "realtime",
- "$comment": "only :internal"
- },
{
"const": "all",
"description": "Since the start of stats in Plausible"
@@ -264,10 +236,6 @@
"const": "time_on_page",
"markdownDescription": "Average time spent on a given page in a visit in seconds. Requires: `event:page` filter or dimension."
},
- {
- "const": "exit_rate",
- "$comment": "only :internal"
- },
{
"const": "total_revenue",
"markdownDescription": "Total revenue",
@@ -331,10 +299,6 @@
{
"type": "string",
"enum": ["time", "time:month", "time:week", "time:day", "time:hour"]
- },
- {
- "const": "time:minute",
- "$comment": "only :internal"
}
]
},
@@ -373,15 +337,7 @@
"minItems": 3,
"maxItems": 3,
"items": [
- {
- "oneOf": [
- { "$ref": "#/definitions/filter_operation_regex" },
- {
- "$ref": "#/definitions/filter_operation_wildcard",
- "$comment": "only :internal"
- }
- ]
- },
+ { "$ref": "#/definitions/filter_operation_regex" },
{
"oneOf": [
{ "$ref": "#/definitions/simple_filter_dimensions" },
diff --git a/test/plausible/funnels_custom_props_goals_test.exs b/test/plausible/funnels_custom_props_goals_test.exs
index e63120348e..8838dcd17a 100644
--- a/test/plausible/funnels_custom_props_goals_test.exs
+++ b/test/plausible/funnels_custom_props_goals_test.exs
@@ -6,6 +6,7 @@ defmodule Plausible.FunnelsCustomPropsGoals do
alias Plausible.Goals
alias Plausible.Funnels
alias Plausible.Stats
+ alias Plausible.Stats.{QueryBuilder, ParsedQueryParams}
describe "Plausible.Stats.Funnel - with custom property goals" do
setup do
@@ -56,7 +57,7 @@ defmodule Plausible.FunnelsCustomPropsGoals do
build(:event, name: "Purchase", user_id: 300)
])
- query = Plausible.Stats.Query.from(site, %{"period" => "all"})
+ query = QueryBuilder.build!(site, %ParsedQueryParams{input_date_range: :all})
{:ok, funnel_data} = Stats.funnel(site, query, funnel.id)
@@ -119,7 +120,7 @@ defmodule Plausible.FunnelsCustomPropsGoals do
)
])
- query = Plausible.Stats.Query.from(site, %{"period" => "all"})
+ query = QueryBuilder.build!(site, %ParsedQueryParams{input_date_range: :all})
{:ok, funnel_data} = Stats.funnel(site, query, funnel.id)
@@ -199,7 +200,7 @@ defmodule Plausible.FunnelsCustomPropsGoals do
)
])
- query = Plausible.Stats.Query.from(site, %{"period" => "all"})
+ query = QueryBuilder.build!(site, %ParsedQueryParams{input_date_range: :all})
{:ok, funnel_data} = Stats.funnel(site, query, funnel.id)
@@ -243,7 +244,7 @@ defmodule Plausible.FunnelsCustomPropsGoals do
build(:event, name: "Convert", user_id: 200)
])
- query = Plausible.Stats.Query.from(site, %{"period" => "all"})
+ query = QueryBuilder.build!(site, %ParsedQueryParams{input_date_range: :all})
{:ok, funnel_data} = Stats.funnel(site, query, funnel.id)
diff --git a/test/plausible/funnels_test.exs b/test/plausible/funnels_test.exs
index 8b8236cf25..6c27110c1d 100644
--- a/test/plausible/funnels_test.exs
+++ b/test/plausible/funnels_test.exs
@@ -6,6 +6,7 @@ defmodule Plausible.FunnelsTest do
alias Plausible.Goals
alias Plausible.Funnels
alias Plausible.Stats
+ alias Plausible.Stats.{QueryBuilder, ParsedQueryParams}
setup do
site = new_site()
@@ -200,7 +201,7 @@ defmodule Plausible.FunnelsTest do
build(:event, name: "Signup", user_id: 666)
])
- query = Plausible.Stats.Query.from(site, %{"period" => "all"})
+ query = QueryBuilder.build!(site, %ParsedQueryParams{input_date_range: :all})
funnel_data = Stats.funnel(site, query, funnel_definition)
@@ -259,7 +260,7 @@ defmodule Plausible.FunnelsTest do
build(:event, name: "Signup", user_id: 666)
])
- query = Plausible.Stats.Query.from(site, %{"period" => "all"})
+ query = QueryBuilder.build!(site, %ParsedQueryParams{input_date_range: :all})
funnel_data = Stats.funnel(site, query, funnel.id)
@@ -309,7 +310,7 @@ defmodule Plausible.FunnelsTest do
[g1, g2, g3]
)
- query = Plausible.Stats.Query.from(site, %{"period" => "all"})
+ query = QueryBuilder.build!(site, %ParsedQueryParams{input_date_range: :all})
funnel_data = Stats.funnel(site, query, funnel.id)
diff --git a/test/plausible/google/api_test.exs b/test/plausible/google/api_test.exs
index 357a3fd44b..2a50f4c137 100644
--- a/test/plausible/google/api_test.exs
+++ b/test/plausible/google/api_test.exs
@@ -3,7 +3,7 @@ defmodule Plausible.Google.APITest do
use Plausible.Test.Support.HTTPMocker
alias Plausible.Google
- alias Plausible.Stats.{DateTimeRange, Query}
+ alias Plausible.Stats.{DateTimeRange, QueryBuilder, ParsedQueryParams}
import ExUnit.CaptureLog
import Mox
@@ -43,7 +43,9 @@ defmodule Plausible.Google.APITest do
)
query =
- Query.from(site, %{"period" => "custom", "from" => "2022-01-01", "to" => "2022-01-05"})
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ input_date_range: {:date_range, ~D[2022-01-01], ~D[2022-01-05]}
+ })
assert {:error, "google_auth_error"} = Google.API.fetch_stats(site, query, {5, 0}, "")
end
@@ -61,7 +63,9 @@ defmodule Plausible.Google.APITest do
)
query =
- Query.from(site, %{"period" => "custom", "from" => "2022-01-01", "to" => "2022-01-05"})
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ input_date_range: {:date_range, ~D[2022-01-01], ~D[2022-01-05]}
+ })
assert {:error, "some_error"} = Google.API.fetch_stats(site, query, {5, 0}, "")
end
@@ -79,7 +83,9 @@ defmodule Plausible.Google.APITest do
)
query =
- Query.from(site, %{"period" => "custom", "from" => "2022-01-01", "to" => "2022-01-05"})
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ input_date_range: {:date_range, ~D[2022-01-01], ~D[2022-01-05]}
+ })
log =
capture_log(fn ->
@@ -105,7 +111,9 @@ defmodule Plausible.Google.APITest do
)
query =
- Query.from(site, %{"period" => "custom", "from" => "2022-01-01", "to" => "2022-01-05"})
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ input_date_range: {:date_range, ~D[2022-01-01], ~D[2022-01-05]}
+ })
assert {:error, "invalid_grant"} = Google.API.fetch_stats(site, query, 5, "")
end
@@ -133,7 +141,9 @@ defmodule Plausible.Google.APITest do
mock_http_with("google_search_console.json")
query =
- Query.from(site, %{"period" => "custom", "from" => "2022-01-01", "to" => "2022-01-05"})
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ input_date_range: {:date_range, ~D[2022-01-01], ~D[2022-01-05]}
+ })
assert {:ok,
[
@@ -164,11 +174,9 @@ defmodule Plausible.Google.APITest do
)
query =
- Plausible.Stats.Query.from(site, %{
- "period" => "custom",
- "from" => "2022-01-01",
- "to" => "2022-01-05",
- "filters" => "event:page==/page"
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ input_date_range: {:date_range, ~D[2022-01-01], ~D[2022-01-05]},
+ filters: [[:is, "event:page", ["/page"]]]
})
assert {:ok, []} = Google.API.fetch_stats(site, query, {5, 0}, "")
@@ -177,12 +185,12 @@ defmodule Plausible.Google.APITest do
test "returns :invalid filters when using filters that cannot be used in Search Console", %{
site: site
} do
+ insert(:goal, event_name: "Signup", site: site)
+
query =
- Plausible.Stats.Query.from(site, %{
- "period" => "custom",
- "from" => "2022-01-01",
- "to" => "2022-01-05",
- "filters" => "event:goal==Signup"
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ input_date_range: {:date_range, ~D[2022-01-01], ~D[2022-01-05]},
+ filters: [[:is, "event:goal", ["Signup"]]]
})
assert {:error, :unsupported_filters} = Google.API.fetch_stats(site, query, 5, "")
diff --git a/test/plausible/stats/comparisons_test.exs b/test/plausible/stats/comparisons_test.exs
index 9d86a917ef..ac34637acb 100644
--- a/test/plausible/stats/comparisons_test.exs
+++ b/test/plausible/stats/comparisons_test.exs
@@ -1,21 +1,20 @@
defmodule Plausible.Stats.ComparisonsTest do
use Plausible.DataCase
- alias Plausible.Stats.{Query, Comparisons}
+ alias Plausible.Stats.{Query, Comparisons, QueryBuilder, ParsedQueryParams, QueryInclude}
setup [:create_user, :create_site]
- def build_query(site, params, now) do
- Query.from(site, params, %{}, now)
- end
-
describe "with period set to this month" do
test "shifts back this month period when mode is previous_period", %{site: site} do
+ Plausible.Stats.Query.Test.fix_now(~U[2023-03-02 14:00:00Z])
+
query =
- build_query(
- site,
- %{"period" => "month", "date" => "2023-03-02", "comparison" => "previous_period"},
- ~U[2023-03-02 14:00:00Z]
- )
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :month,
+ relative_date: ~D[2023-03-02],
+ include: %QueryInclude{compare: :previous_period}
+ })
comparison_query = Comparisons.get_comparison_query(query)
@@ -25,12 +24,15 @@ defmodule Plausible.Stats.ComparisonsTest do
test "shifts back this month period when it's the first day of the month and mode is previous_period",
%{site: site} do
+ Plausible.Stats.Query.Test.fix_now(~U[2023-03-01 14:00:00Z])
+
query =
- build_query(
- site,
- %{"period" => "month", "date" => "2023-03-01", "comparison" => "previous_period"},
- ~U[2023-03-01 14:00:00Z]
- )
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :month,
+ relative_date: ~D[2023-03-01],
+ include: %QueryInclude{compare: :previous_period}
+ })
comparison_query = Comparisons.get_comparison_query(query)
@@ -40,17 +42,15 @@ defmodule Plausible.Stats.ComparisonsTest do
test "matches the day of the week when nearest day is original query start date and mode is previous_period",
%{site: site} do
+ Plausible.Stats.Query.Test.fix_now(~U[2023-03-02 14:00:00Z])
+
query =
- build_query(
- site,
- %{
- "period" => "month",
- "date" => "2023-03-02",
- "comparison" => "previous_period",
- "match_day_of_week" => "true"
- },
- ~U[2023-03-02 14:00:00Z]
- )
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :month,
+ relative_date: ~D[2023-03-02],
+ include: %QueryInclude{compare: :previous_period, compare_match_day_of_week: true}
+ })
comparison_query = Comparisons.get_comparison_query(query)
@@ -61,12 +61,15 @@ defmodule Plausible.Stats.ComparisonsTest do
test "custom time zone sets timezone to UTC" do
site = insert(:site, timezone: "US/Eastern")
+ Plausible.Stats.Query.Test.fix_now(~U[2023-03-02 14:00:00Z])
+
query =
- build_query(
- site,
- %{"period" => "month", "date" => "2023-03-02", "comparison" => "previous_period"},
- ~U[2023-03-02 14:00:00Z]
- )
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :month,
+ relative_date: ~D[2023-03-02],
+ include: %QueryInclude{compare: :previous_period}
+ })
comparison_query = Comparisons.get_comparison_query(query)
@@ -77,12 +80,15 @@ defmodule Plausible.Stats.ComparisonsTest do
describe "with period set to previous month" do
test "shifts back using the same number of days when mode is previous_period", %{site: site} do
+ Plausible.Stats.Query.Test.fix_now(~U[2023-03-01 14:00:00Z])
+
query =
- build_query(
- site,
- %{"period" => "month", "date" => "2023-02-01", "comparison" => "previous_period"},
- ~U[2023-03-01 14:00:00Z]
- )
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :month,
+ relative_date: ~D[2023-02-01],
+ include: %QueryInclude{compare: :previous_period}
+ })
comparison_query = Comparisons.get_comparison_query(query)
@@ -91,12 +97,15 @@ defmodule Plausible.Stats.ComparisonsTest do
end
test "shifts back the full month when mode is year_over_year", %{site: site} do
+ Plausible.Stats.Query.Test.fix_now(~U[2023-03-01 14:00:00Z])
+
query =
- build_query(
- site,
- %{"period" => "month", "date" => "2023-02-01", "comparison" => "year_over_year"},
- ~U[2023-03-01 14:00:00Z]
- )
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :month,
+ relative_date: ~D[2023-02-01],
+ include: %QueryInclude{compare: :year_over_year}
+ })
comparison_query = Comparisons.get_comparison_query(query)
@@ -107,12 +116,15 @@ defmodule Plausible.Stats.ComparisonsTest do
test "shifts back whole month plus one day when mode is year_over_year and a leap year", %{
site: site
} do
+ Plausible.Stats.Query.Test.fix_now(~U[2023-03-01 14:00:00Z])
+
query =
- build_query(
- site,
- %{"period" => "month", "date" => "2020-02-01", "comparison" => "year_over_year"},
- ~U[2023-03-01 14:00:00Z]
- )
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :month,
+ relative_date: ~D[2020-02-01],
+ include: %QueryInclude{compare: :year_over_year}
+ })
comparison_query = Comparisons.get_comparison_query(query)
@@ -123,17 +135,15 @@ defmodule Plausible.Stats.ComparisonsTest do
test "matches the day of the week when mode is previous_period keeping the same day", %{
site: site
} do
+ Plausible.Stats.Query.Test.fix_now(~U[2023-03-01 14:00:00Z])
+
query =
- build_query(
- site,
- %{
- "period" => "month",
- "date" => "2023-02-01",
- "comparison" => "previous_period",
- "match_day_of_week" => "true"
- },
- ~U[2023-03-01 14:00:00Z]
- )
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :month,
+ relative_date: ~D[2023-02-01],
+ include: %QueryInclude{compare: :previous_period, compare_match_day_of_week: true}
+ })
comparison_query = Comparisons.get_comparison_query(query)
@@ -142,17 +152,15 @@ defmodule Plausible.Stats.ComparisonsTest do
end
test "matches the day of the week when mode is previous_period", %{site: site} do
+ Plausible.Stats.Query.Test.fix_now(~U[2023-03-01 14:00:00Z])
+
query =
- build_query(
- site,
- %{
- "period" => "month",
- "date" => "2023-01-01",
- "comparison" => "previous_period",
- "match_day_of_week" => "true"
- },
- ~U[2023-03-01 14:00:00Z]
- )
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :month,
+ relative_date: ~D[2023-01-01],
+ include: %QueryInclude{compare: :previous_period, compare_match_day_of_week: true}
+ })
comparison_query = Comparisons.get_comparison_query(query)
@@ -164,10 +172,11 @@ defmodule Plausible.Stats.ComparisonsTest do
describe "year_over_year, exact dates behavior with leap years" do
test "start of the year matching", %{site: site} do
query =
- Query.from(site, %{
- "period" => "7d",
- "date" => "2021-01-05",
- "comparison" => "year_over_year"
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: {:last_n_days, 7},
+ relative_date: ~D[2021-01-05],
+ include: %QueryInclude{compare: :year_over_year}
})
comparison_query = Comparisons.get_comparison_query(query)
@@ -179,10 +188,11 @@ defmodule Plausible.Stats.ComparisonsTest do
test "leap day matching", %{site: site} do
query =
- Query.from(site, %{
- "period" => "7d",
- "date" => "2021-03-04",
- "comparison" => "year_over_year"
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: {:last_n_days, 7},
+ relative_date: ~D[2021-03-04],
+ include: %QueryInclude{compare: :year_over_year}
})
comparison_query = Comparisons.get_comparison_query(query)
@@ -195,10 +205,11 @@ defmodule Plausible.Stats.ComparisonsTest do
test "end of the year matching", %{site: site} do
query =
- Query.from(site, %{
- "period" => "7d",
- "date" => "2021-11-25",
- "comparison" => "year_over_year"
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: {:last_n_days, 7},
+ relative_date: ~D[2021-11-25],
+ include: %QueryInclude{compare: :year_over_year}
})
comparison_query = Comparisons.get_comparison_query(query)
@@ -211,12 +222,15 @@ defmodule Plausible.Stats.ComparisonsTest do
describe "with period set to year to date" do
test "shifts back by the same number of days when mode is previous_period", %{site: site} do
+ Plausible.Stats.Query.Test.fix_now(~U[2023-03-01 14:00:00Z])
+
query =
- build_query(
- site,
- %{"period" => "year", "date" => "2023-03-01", "comparison" => "previous_period"},
- ~U[2023-03-01 14:00:00Z]
- )
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :year,
+ relative_date: ~D[2023-03-01],
+ include: %QueryInclude{compare: :previous_period}
+ })
comparison_query = Comparisons.get_comparison_query(query)
@@ -225,12 +239,15 @@ defmodule Plausible.Stats.ComparisonsTest do
end
test "shifts back by the same number of days when mode is year_over_year", %{site: site} do
+ Plausible.Stats.Query.Test.fix_now(~U[2023-03-01 14:00:00Z])
+
query =
- build_query(
- site,
- %{"period" => "year", "date" => "2023-03-01", "comparison" => "year_over_year"},
- ~U[2023-03-01 14:00:00Z]
- )
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :year,
+ relative_date: ~D[2023-03-01],
+ include: %QueryInclude{compare: :year_over_year}
+ })
comparison_query = Comparisons.get_comparison_query(query)
@@ -239,17 +256,15 @@ defmodule Plausible.Stats.ComparisonsTest do
end
test "matches the day of the week when mode is year_over_year", %{site: site} do
+ Plausible.Stats.Query.Test.fix_now(~U[2023-03-01 14:00:00Z])
+
query =
- build_query(
- site,
- %{
- "period" => "year",
- "date" => "2023-03-01",
- "comparison" => "year_over_year",
- "match_day_of_week" => "true"
- },
- ~U[2023-03-01 14:00:00Z]
- )
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :year,
+ relative_date: ~D[2023-03-01],
+ include: %QueryInclude{compare: :year_over_year, compare_match_day_of_week: true}
+ })
comparison_query = Comparisons.get_comparison_query(query)
@@ -261,10 +276,11 @@ defmodule Plausible.Stats.ComparisonsTest do
describe "with period set to previous year" do
test "shifts back a whole year when mode is year_over_year", %{site: site} do
query =
- Query.from(site, %{
- "period" => "year",
- "date" => "2022-03-02",
- "comparison" => "year_over_year"
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :year,
+ relative_date: ~D[2022-03-02],
+ include: %QueryInclude{compare: :year_over_year}
})
comparison_query = Comparisons.get_comparison_query(query)
@@ -275,10 +291,11 @@ defmodule Plausible.Stats.ComparisonsTest do
test "shifts back a whole year when mode is previous_period", %{site: site} do
query =
- Query.from(site, %{
- "period" => "year",
- "date" => "2022-03-02",
- "comparison" => "previous_period"
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :year,
+ relative_date: ~D[2022-03-02],
+ include: %QueryInclude{compare: :previous_period}
})
comparison_query = Comparisons.get_comparison_query(query)
@@ -291,10 +308,10 @@ defmodule Plausible.Stats.ComparisonsTest do
describe "with period set to custom" do
test "shifts back by the same number of days when mode is previous_period", %{site: site} do
query =
- Query.from(site, %{
- "period" => "custom",
- "date" => "2023-01-01,2023-01-07",
- "comparison" => "previous_period"
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: {:date_range, ~D[2023-01-01], ~D[2023-01-07]},
+ include: %QueryInclude{compare: :previous_period}
})
comparison_query = Comparisons.get_comparison_query(query)
@@ -305,10 +322,10 @@ defmodule Plausible.Stats.ComparisonsTest do
test "shifts back to last year when mode is year_over_year", %{site: site} do
query =
- Query.from(site, %{
- "period" => "custom",
- "date" => "2023-01-01,2023-01-07",
- "comparison" => "year_over_year"
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: {:date_range, ~D[2023-01-01], ~D[2023-01-07]},
+ include: %QueryInclude{compare: :year_over_year}
})
comparison_query = Comparisons.get_comparison_query(query)
@@ -321,12 +338,10 @@ defmodule Plausible.Stats.ComparisonsTest do
describe "with mode set to custom" do
test "sets first and last dates", %{site: site} do
query =
- Query.from(site, %{
- "period" => "custom",
- "date" => "2023-01-01,2023-01-07",
- "comparison" => "custom",
- "compare_from" => "2022-05-25",
- "compare_to" => "2022-05-30"
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: {:date_range, ~D[2023-01-01], ~D[2023-01-07]},
+ include: %QueryInclude{compare: {:date_range, ~D[2022-05-25], ~D[2022-05-30]}}
})
comparison_query = Comparisons.get_comparison_query(query)
@@ -338,7 +353,7 @@ defmodule Plausible.Stats.ComparisonsTest do
describe "add_comparison_filters" do
test "no results doesn't update filters", %{site: site} do
- query = build_comparison_query(site, %{"dimensions" => ["visit:browser"]})
+ query = build_comparison_query(site, %ParsedQueryParams{dimensions: ["visit:browser"]})
result_query = Comparisons.add_comparison_filters(query, [])
@@ -346,7 +361,7 @@ defmodule Plausible.Stats.ComparisonsTest do
end
test "no dimensions doesn't update filters", %{site: site} do
- query = build_comparison_query(site, %{})
+ query = build_comparison_query(site, %ParsedQueryParams{})
result_query =
Comparisons.add_comparison_filters(query, [%{dimensions: [], metrics: [123]}])
@@ -355,7 +370,7 @@ defmodule Plausible.Stats.ComparisonsTest do
end
test "no time dimension doesn't update filters", %{site: site} do
- query = build_comparison_query(site, %{"dimensions" => ["time:day"]})
+ query = build_comparison_query(site, %ParsedQueryParams{dimensions: ["time:day"]})
result_query =
Comparisons.add_comparison_filters(query, [%{dimensions: ["2024-01-01"], metrics: [123]}])
@@ -364,10 +379,7 @@ defmodule Plausible.Stats.ComparisonsTest do
end
test "updates filters in a single-row case", %{site: site} do
- query =
- build_comparison_query(site, %{
- "dimensions" => ["visit:browser"]
- })
+ query = build_comparison_query(site, %ParsedQueryParams{dimensions: ["visit:browser"]})
result_query =
Comparisons.add_comparison_filters(query, [%{dimensions: ["Chrome"], metrics: [123]}])
@@ -379,9 +391,9 @@ defmodule Plausible.Stats.ComparisonsTest do
test "updates filters for a complex case", %{site: site} do
query =
- build_comparison_query(site, %{
- "dimensions" => ["visit:browser", "visit:browser_version", "time:day"],
- "filters" => [["is", "visit:country_name", ["Estonia"]]]
+ build_comparison_query(site, %ParsedQueryParams{
+ dimensions: ["visit:browser", "visit:browser_version", "time:day"],
+ filters: [[:is, "visit:country_name", ["Estonia"]]]
})
main_query_results = [
@@ -425,26 +437,18 @@ defmodule Plausible.Stats.ComparisonsTest do
end
end
- defp build_comparison_query(site, params) do
- query =
- Query.parse_and_build!(
- site,
- :internal,
- Map.merge(
- %{
- "site_id" => site.domain,
- "metrics" => ["pageviews"],
- "date_range" => ["2024-01-01", "2024-02-01"],
- "include" => %{"compare" => "previous_period"}
- },
- params
- )
+ defp build_comparison_query(site, %ParsedQueryParams{} = params) do
+ QueryBuilder.build!(
+ site,
+ struct!(params,
+ metrics: [:pageviews],
+ input_date_range: {:date_range, ~D[2024-01-01], ~D[2024-02-01]},
+ include: %QueryInclude{compare: :previous_period}
)
-
- query
+ )
end
- def date_range_length(query) do
+ defp date_range_length(query) do
query
|> Query.date_range()
|> Enum.count()
diff --git a/test/plausible/stats/query/api_query_parser_test.exs b/test/plausible/stats/query/api_query_parser_test.exs
index b17f8703cf..d26a221aba 100644
--- a/test/plausible/stats/query/api_query_parser_test.exs
+++ b/test/plausible/stats/query/api_query_parser_test.exs
@@ -4,7 +4,7 @@ defmodule Plausible.Stats.ApiQueryParserTest do
test "parsing empty map fails" do
assert {:error, "#: Required properties site_id, metrics, date_range were not present."} =
- parse(:public, %{})
+ parse(%{})
end
test "invalid metric passed" do
@@ -14,7 +14,6 @@ defmodule Plausible.Stats.ApiQueryParserTest do
"date_range" => "all"
}
- assert {:error, "#/metrics/1: Invalid metric \"event:name\""} =
- parse(:public, params)
+ assert {:error, "#/metrics/1: Invalid metric \"event:name\""} = parse(params)
end
end
diff --git a/test/plausible/stats/query/query_builder_test.exs b/test/plausible/stats/query/query_builder_test.exs
new file mode 100644
index 0000000000..eb6e864b97
--- /dev/null
+++ b/test/plausible/stats/query/query_builder_test.exs
@@ -0,0 +1,301 @@
+defmodule Plausible.Stats.QueryBuilderTest do
+ use Plausible.DataCase
+ alias Plausible.Stats.{DateTimeRange, ParsedQueryParams, QueryBuilder, Query}
+
+ @now DateTime.new!(~D[2021-05-05], ~T[12:30:00], "Etc/UTC")
+ @date_range_realtime %DateTimeRange{
+ first: DateTime.new!(~D[2021-05-05], ~T[12:25:00], "Etc/UTC"),
+ last: DateTime.new!(~D[2021-05-05], ~T[12:30:05], "Etc/UTC")
+ }
+ @date_range_30m %DateTimeRange{
+ first: DateTime.new!(~D[2021-05-05], ~T[12:00:00], "Etc/UTC"),
+ last: DateTime.new!(~D[2021-05-05], ~T[12:30:05], "Etc/UTC")
+ }
+ @date_range_day %DateTimeRange{
+ first: DateTime.new!(~D[2021-05-05], ~T[00:00:00], "Etc/UTC"),
+ last: DateTime.new!(~D[2021-05-05], ~T[23:59:59], "Etc/UTC")
+ }
+ @date_range_7d %DateTimeRange{
+ first: DateTime.new!(~D[2021-04-28], ~T[00:00:00], "Etc/UTC"),
+ last: DateTime.new!(~D[2021-05-04], ~T[23:59:59], "Etc/UTC")
+ }
+ @date_range_10d %DateTimeRange{
+ first: DateTime.new!(~D[2021-04-25], ~T[00:00:00], "Etc/UTC"),
+ last: DateTime.new!(~D[2021-05-04], ~T[23:59:59], "Etc/UTC")
+ }
+ @date_range_30d %DateTimeRange{
+ first: DateTime.new!(~D[2021-04-05], ~T[00:00:00], "Etc/UTC"),
+ last: DateTime.new!(~D[2021-05-04], ~T[23:59:59], "Etc/UTC")
+ }
+ @date_range_month %DateTimeRange{
+ first: DateTime.new!(~D[2021-05-01], ~T[00:00:00], "Etc/UTC"),
+ last: DateTime.new!(~D[2021-05-31], ~T[23:59:59], "Etc/UTC")
+ }
+ @date_range_3mo %DateTimeRange{
+ first: DateTime.new!(~D[2021-02-01], ~T[00:00:00], "Etc/UTC"),
+ last: DateTime.new!(~D[2021-04-30], ~T[23:59:59], "Etc/UTC")
+ }
+ @date_range_6mo %DateTimeRange{
+ first: DateTime.new!(~D[2020-11-01], ~T[00:00:00], "Etc/UTC"),
+ last: DateTime.new!(~D[2021-04-30], ~T[23:59:59], "Etc/UTC")
+ }
+ @date_range_year %DateTimeRange{
+ first: DateTime.new!(~D[2021-01-01], ~T[00:00:00], "Etc/UTC"),
+ last: DateTime.new!(~D[2021-12-31], ~T[23:59:59], "Etc/UTC")
+ }
+ @date_range_12mo %DateTimeRange{
+ first: DateTime.new!(~D[2020-05-01], ~T[00:00:00], "Etc/UTC"),
+ last: DateTime.new!(~D[2021-04-30], ~T[23:59:59], "Etc/UTC")
+ }
+
+ setup [:create_user, :create_site]
+
+ setup do
+ Plausible.Stats.Query.Test.fix_now(@now)
+ :ok
+ end
+
+ describe "filter validation" do
+ for operation <- [
+ :is,
+ :is_not,
+ :matches_wildcard,
+ :matches_wildcard_not,
+ :matches,
+ :matches_not,
+ :contains,
+ :contains_not
+ ] do
+ test "valid simple #{operation} filter passes validation", %{site: site} do
+ params = %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :all,
+ filters: [[unquote(operation), "event:name", ["foo"]]]
+ }
+
+ assert {:ok, query} = QueryBuilder.build(site, params)
+
+ assert_matches %Query{filters: [[^unquote(operation), "event:name", ["foo"]]]} = query
+ end
+
+ test "valid complex nested #{operation} filter passes validation", %{site: site} do
+ params = %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :all,
+ filters: [
+ [
+ :not,
+ [
+ :and,
+ [
+ [unquote(operation), "event:name", ["foo"]],
+ [unquote(operation), "event:name", ["bar"]]
+ ]
+ ]
+ ]
+ ]
+ }
+
+ assert {:ok, query} = QueryBuilder.build(site, params)
+
+ assert_matches %Query{
+ filters: [
+ [
+ :not,
+ [
+ :and,
+ [
+ [unquote(operation), "event:name", ["foo"]],
+ [unquote(operation), "event:name", ["bar"]]
+ ]
+ ]
+ ]
+ ]
+ } = query
+ end
+ end
+
+ test "event goal name is checked within behavioral filters", %{site: site} do
+ insert(:goal, %{site: site, event_name: "Signup"})
+
+ params = %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :all,
+ filters: [[:has_done, [:is, "event:goal", ["Unknown"]]]]
+ }
+
+ assert {:error, error} = QueryBuilder.build(site, params)
+
+ assert error ==
+ "Invalid filters. The goal `Unknown` is not configured for this site. Find out how to configure goals here: https://plausible.io/docs/stats-api#filtering-by-goals"
+ end
+
+ for operation <- [:matches, :matches_not, :matches_wildcard, :matches_wildcard_not] do
+ test "case_sensitive modifier is not valid for #{operation}", %{site: site} do
+ assert {:error, error} =
+ QueryBuilder.build(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :all,
+ filters: [
+ [unquote(operation), "event:page", ["a"], %{case_insensitive: true}]
+ ]
+ })
+
+ assert error =~ "Invalid filters."
+ assert error =~ "case_sensitive modifier is not allowed with pattern operators"
+ assert error =~ Atom.to_string(unquote(operation))
+ end
+ end
+
+ test "prohibits case_sensitive modifier with pattern operator in a complex filter tree", %{
+ site: site
+ } do
+ assert {:error, error} =
+ QueryBuilder.build(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :all,
+ filters: [
+ [
+ :or,
+ [
+ [
+ :and,
+ [
+ [:is, "visit:city_name", ["London"]],
+ [:not, [:is, "visit:country_name", ["Canada"]]]
+ ]
+ ],
+ [:matches, "event:page", ["a"], %{case_insensitive: true}]
+ ]
+ ]
+ ]
+ })
+
+ assert error =~ "Invalid filters."
+ assert error =~ "case_sensitive modifier is not allowed with pattern operators"
+ assert error =~ ":matches"
+ end
+ end
+
+ describe "date range" do
+ for {input_date_range, expected_utc_time_range} <- [
+ {:realtime, @date_range_realtime},
+ {:realtime_30m, @date_range_30m}
+ ] do
+ test "builds utc_time_range for #{input_date_range} input_date_range", %{site: site} do
+ assert {:ok, query} =
+ QueryBuilder.build(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: unquote(input_date_range)
+ })
+
+ assert query.utc_time_range == unquote(Macro.escape(expected_utc_time_range))
+ end
+ end
+
+ test "utc_time_range construction respects relative_date", %{site: site} do
+ relative_date = @now |> DateTime.to_date()
+
+ # Replace the fixed now. Otherwise this test could pass ignoring relative_date
+ Plausible.Stats.Query.Test.fix_now(DateTime.utc_now(:second))
+
+ for {date_range_shortcut, expected_utc_time_range} <- [
+ {:day, @date_range_day},
+ {{:last_n_days, 7}, @date_range_7d},
+ {{:last_n_days, 10}, @date_range_10d},
+ {{:last_n_days, 30}, @date_range_30d},
+ {:month, @date_range_month},
+ {{:last_n_months, 3}, @date_range_3mo},
+ {{:last_n_months, 6}, @date_range_6mo},
+ {{:last_n_months, 12}, @date_range_12mo},
+ {:year, @date_range_year}
+ ] do
+ assert {:ok, query} =
+ QueryBuilder.build(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ relative_date: relative_date,
+ input_date_range: date_range_shortcut
+ })
+
+ assert query.utc_time_range == expected_utc_time_range
+ end
+ end
+ end
+
+ describe "exit_rate metric" do
+ test "fails validation without visit:exit_page dimension", %{site: site} do
+ assert {:error, error} =
+ QueryBuilder.build(site, %ParsedQueryParams{
+ metrics: [:exit_rate],
+ input_date_range: :all
+ })
+
+ assert error ==
+ "Metric `exit_rate` requires a `\"visit:exit_page\"` dimension. No other dimensions are allowed."
+ end
+
+ test "fails validation with event only filters", %{site: site} do
+ assert {:error, error} =
+ QueryBuilder.build(site, %ParsedQueryParams{
+ metrics: [:exit_rate],
+ dimensions: ["visit:exit_page"],
+ filters: [[:is, "event:page", ["/"]]],
+ input_date_range: :all
+ })
+
+ assert error == "Metric `exit_rate` cannot be queried when filtering on event dimensions."
+ end
+
+ test "fails validation with event metrics", %{site: site} do
+ assert {:error, error} =
+ QueryBuilder.build(site, %ParsedQueryParams{
+ metrics: [:exit_rate, :pageviews],
+ dimensions: ["visit:exit_page"],
+ input_date_range: :all
+ })
+
+ assert error ==
+ "Event metric(s) `pageviews` cannot be queried along with session dimension(s) `visit:exit_page`"
+ end
+
+ test "passes validation", %{site: site} do
+ assert {:ok, query} =
+ QueryBuilder.build(site, %ParsedQueryParams{
+ metrics: [:exit_rate],
+ dimensions: ["visit:exit_page"],
+ input_date_range: :all
+ })
+
+ assert_matches %Query{
+ metrics: [:exit_rate],
+ dimensions: ["visit:exit_page"]
+ } = query
+ end
+ end
+
+ on_ee do
+ describe "query.consolidated_site_ids" do
+ test "is set to nil when site is regular", %{site: site} do
+ assert {:ok, %Query{consolidated_site_ids: nil}} =
+ QueryBuilder.build(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :all
+ })
+ end
+
+ test "is set to a list of site_ids when site is consolidated", %{site: site} do
+ new_site(team: site.team)
+ cv = new_consolidated_view(site.team)
+
+ assert {:ok, %Query{consolidated_site_ids: consolidated_site_ids}} =
+ QueryBuilder.build(cv, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :all
+ })
+
+ assert length(consolidated_site_ids) == 2
+ assert site.id in consolidated_site_ids
+ end
+ end
+ end
+end
diff --git a/test/plausible/stats/query/query_parse_and_build_test.exs b/test/plausible/stats/query/query_parse_and_build_test.exs
index cfcbcd98d5..eea6fed64b 100644
--- a/test/plausible/stats/query/query_parse_and_build_test.exs
+++ b/test/plausible/stats/query/query_parse_and_build_test.exs
@@ -5,14 +5,6 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
alias Plausible.Stats.{Query, DateTimeRange, Filters}
@now DateTime.new!(~D[2021-05-05], ~T[12:30:00], "Etc/UTC")
- @date_range_realtime %DateTimeRange{
- first: DateTime.new!(~D[2021-05-05], ~T[12:25:00], "Etc/UTC"),
- last: DateTime.new!(~D[2021-05-05], ~T[12:30:05], "Etc/UTC")
- }
- @date_range_30m %DateTimeRange{
- first: DateTime.new!(~D[2021-05-05], ~T[12:00:00], "Etc/UTC"),
- last: DateTime.new!(~D[2021-05-05], ~T[12:30:05], "Etc/UTC")
- }
@date_range_day %DateTimeRange{
first: DateTime.new!(~D[2021-05-05], ~T[00:00:00], "Etc/UTC"),
last: DateTime.new!(~D[2021-05-05], ~T[23:59:59], "Etc/UTC")
@@ -88,6 +80,17 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
defp goal_names(goals), do: Enum.map(goals, & &1.display_name) |> Enum.sort()
describe "metrics" do
+ test "public API does not recognize exit_rate metric", %{site: site} do
+ params = %{
+ "site_id" => site.domain,
+ "metrics" => ["exit_rate"],
+ "date_range" => "all"
+ }
+
+ assert {:error, error} = Query.parse_and_build(site, params)
+ assert error =~ "Invalid metric"
+ end
+
test "valid metrics passed", %{site: site} do
params = %{
"site_id" => site.domain,
@@ -95,7 +98,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"date_range" => "all"
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors, :events],
@@ -123,7 +126,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"date_range" => "all"
}
- assert {:ok, query} = Query.parse_and_build(site, :internal, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [
@@ -152,7 +155,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
}
assert {:error, "#/metrics: Expected items to be unique but they were not."} =
- Query.parse_and_build(site, :public, params)
+ Query.parse_and_build(site, params)
end
test "no metrics passed", %{site: site} do
@@ -163,7 +166,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
}
assert {:error, "#/metrics: Expected a minimum of 1 items but got 0."} =
- Query.parse_and_build(site, :public, params)
+ Query.parse_and_build(site, params)
end
end
@@ -171,8 +174,6 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
for operation <- [
:is,
:is_not,
- :matches_wildcard,
- :matches_wildcard_not,
:matches,
:matches_not,
:contains,
@@ -188,7 +189,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:ok, query} = Query.parse_and_build(site, :internal, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -214,7 +215,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:error, error} = Query.parse_and_build(site, :internal, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"#/filters/0: Invalid filter [\"#{unquote(operation)}\", \"event:name\", \"foo\"]"
@@ -232,7 +233,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"#/filters/0: Invalid filter [\"#{unquote(operation)}\", \"event:name\", [\"foo\"]]"
@@ -263,7 +264,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == ~s(#/filters/0: Invalid filter #{inspect(unquote(too_short_filter))})
end
@@ -289,7 +290,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == ~s(#/filters/0: Invalid filter #{inspect(unquote(too_long_filter))})
end
@@ -305,7 +306,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "#/filters/0: Invalid filter [\"exists?\", \"event:name\", [\"foo\"]]"
end
@@ -319,7 +320,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -349,7 +350,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -380,7 +381,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -407,7 +408,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "#/filters/0: Invalid filter [\"is\", \"event:device\", [\"foo\"]]"
end
@@ -422,7 +423,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "#/filters/0: Invalid filter [\"is\", \"visit:name\", [\"foo\"]]"
end
@@ -435,7 +436,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => "foobar"
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "#/filters: Type mismatch. Expected Array but got String."
end
@@ -447,7 +448,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "visit:os_version", [123]]]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "Invalid filter '[\"is\", \"visit:os_version\", [123]]'."
end
@@ -459,7 +460,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "visit:city", [123, 456]]]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -483,7 +484,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "visit:city", ["123", "456"]]]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -507,7 +508,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "visit:country", ["USA"]]]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"Invalid visit:country filter, visit:country needs to be a valid 2-letter country code."
@@ -535,7 +536,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -585,7 +586,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -618,7 +619,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"Invalid filters. Behavioral filters (has_done, has_not_done) can only be used with event dimension filters."
@@ -634,7 +635,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"Invalid filters. Behavioral filters (has_done, has_not_done) cannot be nested."
@@ -649,7 +650,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [[unquote(operator), []]]
}
- assert {:error, error} = Query.parse_and_build(site, :internal, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "#/filters/0: Invalid filter [\"#{unquote(operator)}\", []]"
end
end
@@ -662,7 +663,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "event:hostname", ["a.plausible.io"]]]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -686,7 +687,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["not", ["is", "event:hostname", ["a.plausible.io"]]]]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"Invalid filters. Dimension `event:hostname` can only be filtered at the top level."
@@ -714,7 +715,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -737,7 +738,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
end
end
- for operation <- [:matches, :matches_not, :matches_wildcard, :matches_wildcard_not] do
+ for operation <- [:matches, :matches_not] do
test "case_sensitive modifier is not valid for #{operation}", %{site: site} do
params = %{
"site_id" => site.domain,
@@ -753,7 +754,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:error, error} = Query.parse_and_build(site, :internal, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"#/filters/0: Invalid filter [\"#{unquote(operation)}\", \"event:hostname\", [\"a.plausible.io\"], %{\"case_sensitive\" => false}]"
@@ -778,7 +779,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "event:goal", ["Signup", "Purchase"]]]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -808,7 +809,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "event:goal", ["signup", "purchase"], %{"case_sensitive" => false}]]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -840,7 +841,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["contains", "event:goal", ["Sign", "pur"]]]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -870,7 +871,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["contains", "event:goal", ["sign", "CONT"], %{"case_sensitive" => false}]]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -905,7 +906,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"include" => %{"imports" => true, "time_labels" => true, "total_rows" => true}
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -936,7 +937,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"include" => "foobar"
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "#/include: Type mismatch. Expected Object but got String."
end
@@ -948,132 +949,11 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"include" => %{"time_labels" => true}
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "Invalid include.time_labels: requires a time dimension."
end
end
- describe "comparisons" do
- test "not allowed in public API", %{site: site} do
- params = %{
- "site_id" => site.domain,
- "metrics" => ["visitors"],
- "date_range" => "all",
- "include" => %{"compare" => "previous_period"}
- }
-
- assert {:error, error} = Query.parse_and_build(site, :public, params)
- assert error == "#/include/compare: Schema does not allow additional properties."
- end
-
- test "previous_period", %{site: site} do
- params = %{
- "site_id" => site.domain,
- "metrics" => ["visitors"],
- "date_range" => "all",
- "include" => %{"compare" => "previous_period"}
- }
-
- assert {:ok, query} = Query.parse_and_build(site, :internal, params)
-
- assert_matches %Query{
- metrics: [:visitors],
- utc_time_range: ^@date_range_day,
- filters: [],
- dimensions: [],
- order_by: nil,
- timezone: ^site.timezone,
- include: %{
- compare: :previous_period,
- compare_match_day_of_week: false,
- imports: false,
- imports_meta: false,
- time_labels: false,
- total_rows: false,
- legacy_time_on_page_cutoff: nil,
- trim_relative_date_range: false
- },
- pagination: %{limit: 10_000, offset: 0}
- } = query
- end
-
- test "year_over_year with match_day_of_week", %{site: site} do
- params = %{
- "site_id" => site.domain,
- "metrics" => ["visitors"],
- "date_range" => "all",
- "include" => %{"compare" => "year_over_year", "compare_match_day_of_week" => true}
- }
-
- assert {:ok, query} = Query.parse_and_build(site, :internal, params)
-
- assert_matches %Query{
- metrics: [:visitors],
- utc_time_range: ^@date_range_day,
- filters: [],
- dimensions: [],
- order_by: nil,
- timezone: ^site.timezone,
- include: %{
- compare: :year_over_year,
- compare_match_day_of_week: true,
- imports: false,
- imports_meta: false,
- time_labels: false,
- total_rows: false,
- legacy_time_on_page_cutoff: nil,
- trim_relative_date_range: false
- },
- pagination: %{limit: 10_000, offset: 0}
- } = query
- end
-
- test "with custom date range", %{site: site} do
- params = %{
- "site_id" => site.domain,
- "metrics" => ["visitors"],
- "date_range" => "all",
- "include" => %{"compare" => ["2021-04-05", "2021-05-04"]}
- }
-
- assert {:ok, query} = Query.parse_and_build(site, :internal, params)
-
- assert_matches %Query{
- metrics: [:visitors],
- utc_time_range: ^@date_range_day,
- filters: [],
- dimensions: [],
- order_by: nil,
- timezone: ^site.timezone,
- include: %{
- compare: {:date_range, ~D[2021-04-05], ~D[2021-05-04]},
- compare_match_day_of_week: false,
- imports_meta: false,
- imports: false,
- time_labels: false,
- total_rows: false,
- legacy_time_on_page_cutoff: nil,
- trim_relative_date_range: false
- },
- pagination: %{limit: 10_000, offset: 0}
- } = query
- end
-
- test "invalid compare", %{site: site} do
- params = %{
- "site_id" => site.domain,
- "metrics" => ["visitors"],
- "date_range" => "all",
- "include" => %{"compare" => "2024-01-01"}
- }
-
- assert {:error, error} = Query.parse_and_build(site, :internal, params)
-
- assert error ==
- "#/include/compare: Expected exactly one of the schemata to match, but none of them did."
- end
- end
-
describe "pagination validation" do
test "setting pagination values", %{site: site} do
params = %{
@@ -1084,7 +964,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"pagination" => %{"limit" => 100, "offset" => 200}
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -1106,7 +986,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"pagination" => %{"limit" => 100_000}
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "#/pagination/limit: Expected the value to be <= 10000"
end
@@ -1118,7 +998,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"pagination" => %{"offset" => -5}
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "#/pagination/offset: Expected the value to be >= 0"
end
end
@@ -1137,7 +1017,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -1172,7 +1052,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"Invalid filters. The goal `Signup` is not configured for this site. Find out how to configure goals here: https://plausible.io/docs/stats-api#filtering-by-goals"
@@ -1188,7 +1068,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"Invalid filters. The goal `Visit /thank-you` is not configured for this site. Find out how to configure goals here: https://plausible.io/docs/stats-api#filtering-by-goals"
@@ -1204,7 +1084,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "#/filters/0: Invalid filter [\"is_not\", \"event:goal\", [\"Signup\"]]"
end
@@ -1225,7 +1105,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"Invalid filters. Dimension `event:goal` can only be filtered at the top level."
@@ -1252,7 +1132,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -1282,25 +1162,22 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
revenue_currencies: %{}
)
end
+ end
- test "name is checked even within behavioral filters", %{site: site} do
- insert(:goal, %{site: site, event_name: "Signup"})
-
- params = %{
- "site_id" => site.domain,
- "metrics" => ["visitors"],
- "date_range" => "all",
- "filters" => [["has_done", ["is", "event:goal", ["Unknown"]]]]
- }
-
- assert {:error, error} = Query.parse_and_build(site, :internal, params)
+ describe "date range validation" do
+ for shortcut <- ["realtime", "30m"] do
+ test "public API does not recognize #{shortcut} date_range", %{site: site} do
+ params = %{
+ "site_id" => site.domain,
+ "metrics" => ["visitors"],
+ "date_range" => unquote(shortcut)
+ }
- assert error ==
- "Invalid filters. The goal `Unknown` is not configured for this site. Find out how to configure goals here: https://plausible.io/docs/stats-api#filtering-by-goals"
+ assert {:error, error} = Query.parse_and_build(site, params)
+ assert error =~ "Invalid date range"
+ end
end
- end
- describe "date range validation" do
for {shortcut, expected_date_range} <- [
{"day", @date_range_day},
{"7d", @date_range_7d},
@@ -1319,33 +1196,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"date_range" => unquote(shortcut)
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
-
- assert_matches %Query{
- metrics: [:visitors, :events],
- utc_time_range: ^unquote(Macro.escape(expected_date_range)),
- filters: [],
- dimensions: [],
- order_by: nil,
- timezone: ^site.timezone,
- include: ^@default_include,
- pagination: %{limit: 10_000, offset: 0}
- } = query
- end
- end
-
- for {shortcut, expected_date_range} <- [
- {"30m", @date_range_30m},
- {"realtime", @date_range_realtime}
- ] do
- test "'#{shortcut}' shortcut is available only in the internal API schema", %{site: site} do
- params = %{
- "site_id" => site.domain,
- "metrics" => ["visitors", "events"],
- "date_range" => unquote(shortcut)
- }
-
- assert {:ok, query} = Query.parse_and_build(site, :internal, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors, :events],
@@ -1357,9 +1208,6 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
include: ^@default_include,
pagination: %{limit: 10_000, offset: 0}
} = query
-
- assert {:error, error} = Query.parse_and_build(site, :public, params)
- assert error == "#/date_range: Invalid date range \"#{unquote(shortcut)}\""
end
end
@@ -1373,7 +1221,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"date_range" => "all"
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors, :events],
@@ -1396,7 +1244,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"date_range" => "all"
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors, :events],
@@ -1417,7 +1265,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"date_range" => ["2021-05-05", "2021-05-05"]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors, :events],
@@ -1444,7 +1292,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
DateTime.new!(~D[2024-01-02], ~T[23:59:59], "Etc/UTC")
)
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors, :events],
@@ -1468,7 +1316,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
expected_utc_time_range =
DateTimeRange.new!(~U[2024-08-29 14:12:34Z], ~U[2024-08-29 17:12:34Z])
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors, :events],
@@ -1490,7 +1338,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"metrics" => ["visitors"]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "#/date_range: Invalid date range #{inspect(unquote(invalid_value))}"
end
@@ -1503,7 +1351,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"metrics" => ["visitors"]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "Invalid date_range \"999999999mo\""
end
@@ -1517,7 +1365,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"metrics" => ["visitors"]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "Invalid date_range '[\"2021-02-03T00:00:00\", \"2021-02-03T23:59:59\"]'."
end
@@ -1529,7 +1377,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"metrics" => ["visitors"]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"#/date_range: Invalid date range [\"2021-02-03T00:00:00-25:00\", \"2021-02-03T23:59:59-25:00\"]"
@@ -1542,60 +1390,12 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"metrics" => ["visitors"]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"#/date_range: Invalid date range [\"2021-02-03T00:00:00Z\", \"2021-02-04\"]"
end
- test "parses date_range relative to date param", %{site: site} do
- date = @now |> DateTime.to_date() |> Date.to_string()
-
- for {date_range_shortcut, expected_date_range} <- [
- {"day", @date_range_day},
- {"7d", @date_range_7d},
- {"10d", @date_range_10d},
- {"30d", @date_range_30d},
- {"month", @date_range_month},
- {"3mo", @date_range_3mo},
- {"6mo", @date_range_6mo},
- {"12mo", @date_range_12mo},
- {"year", @date_range_year}
- ] do
- params = %{
- "site_id" => site.domain,
- "metrics" => ["visitors"],
- "date_range" => date_range_shortcut,
- "date" => date
- }
-
- assert {:ok, query} = Query.parse_and_build(site, :internal, params)
-
- assert_matches %Query{
- metrics: [:visitors],
- utc_time_range: ^expected_date_range,
- filters: [],
- dimensions: [],
- order_by: nil,
- timezone: ^site.timezone,
- include: ^@default_include,
- pagination: %{limit: 10_000, offset: 0}
- } = query
- end
- end
-
- test "date parameter is not available in the public API", %{site: site} do
- params = %{
- "site_id" => site.domain,
- "metrics" => ["visitors", "events"],
- "date_range" => "month",
- "date" => "2021-05-05"
- }
-
- assert {:error, error} = Query.parse_and_build(site, :public, params)
- assert error == "#/date: Schema does not allow additional properties."
- end
-
test "parses date_range.first into a datetime right after the gap in site.timezone", %{
site: site
} do
@@ -1610,7 +1410,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
expected_utc_time_range =
DateTimeRange.new!(~U[2022-09-11 04:00:00Z], ~U[2022-09-12 02:59:59Z])
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -1638,7 +1438,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
expected_utc_time_range =
DateTimeRange.new!(~U[2023-11-05 05:00:00Z], ~U[2023-11-06 04:59:59Z])
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -1666,7 +1466,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
expected_utc_time_range =
DateTimeRange.new!(~U[2024-03-23 03:00:00Z], ~U[2024-03-24 02:59:59Z])
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -1693,7 +1493,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => [prefixed_dimension]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -1719,7 +1519,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => [prefixed_dimension]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -1742,32 +1542,10 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => ["time:minute"]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "#/dimensions/0: Invalid dimension \"time:minute\""
end
- test "time:minute dimension passes internal schema validation", %{site: site} do
- params = %{
- "site_id" => site.domain,
- "metrics" => ["visitors"],
- "date_range" => "all",
- "dimensions" => ["time:minute"]
- }
-
- assert {:ok, query} = Query.parse_and_build(site, :internal, params)
-
- assert_matches %Query{
- metrics: [:visitors],
- utc_time_range: ^@date_range_day,
- filters: [],
- dimensions: ["time:minute"],
- order_by: nil,
- timezone: ^site.timezone,
- include: ^@default_include,
- pagination: %{limit: 10_000, offset: 0}
- } = query
- end
-
test "custom properties dimension", %{site: site} do
params = %{
"site_id" => site.domain,
@@ -1776,7 +1554,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => ["event:props:foobar"]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -1798,7 +1576,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => ["event:props:"]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "#/dimensions/0: Invalid dimension \"event:props:\""
end
@@ -1810,7 +1588,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => ["visitors"]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "#/dimensions/0: Invalid dimension \"visitors\""
end
@@ -1822,7 +1600,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => "foobar"
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "#/dimensions: Type mismatch. Expected Array but got String."
end
@@ -1834,7 +1612,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => ["event:name", "event:name"]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "#/dimensions: Expected items to be unique but they were not."
end
end
@@ -1848,7 +1626,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"order_by" => [["events", "desc"], ["visitors", "asc"]]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors, :events],
@@ -1871,7 +1649,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"order_by" => [["event:name", "desc"]]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors],
@@ -1893,7 +1671,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"order_by" => [["visssss", "desc"]]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "#/order_by/0/0: Invalid value in order_by \"visssss\""
end
@@ -1905,7 +1683,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"order_by" => [["events", "desc"]]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"Invalid order_by entry '{:events, :desc}'. Entry is not a queried metric or dimension."
@@ -1919,7 +1697,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"order_by" => [["event:name", "desc"]]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"Invalid order_by entry '{\"event:name\", :desc}'. Entry is not a queried metric or dimension."
@@ -1937,7 +1715,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["not", ["is", "event:props:foobar", ["foo"]]]]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"The owner of this site does not have access to the custom properties feature."
@@ -1953,7 +1731,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => ["event:props:foobar"]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"The owner of this site does not have access to the custom properties feature."
@@ -1968,7 +1746,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"date_range" => "all"
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"Metric `conversion_rate` can only be queried with event:goal filters or dimensions."
@@ -1985,7 +1763,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "event:goal", ["Signup"]]]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:conversion_rate],
@@ -2018,7 +1796,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => ["event:goal"]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:conversion_rate],
@@ -2049,7 +1827,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => ["event:goal"]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:conversion_rate, :group_conversion_rate],
@@ -2074,77 +1852,13 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => ["event:goal"]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"Invalid filters. When `conversion_rate` or `group_conversion_rate` metrics are used, custom property filters can only be used on top level."
end
end
- describe "exit_rate metric" do
- test "fails validation without visit:exit_page dimension", %{site: site} do
- params = %{
- "site_id" => site.domain,
- "metrics" => ["exit_rate"],
- "date_range" => "all"
- }
-
- assert {:error, error} = Query.parse_and_build(site, :internal, params)
-
- assert error ==
- "Metric `exit_rate` requires a `\"visit:exit_page\"` dimension. No other dimensions are allowed."
- end
-
- test "fails validation with event only filters", %{site: site} do
- params = %{
- "site_id" => site.domain,
- "metrics" => ["exit_rate"],
- "dimensions" => ["visit:exit_page"],
- "filters" => [["is", "event:page", ["/"]]],
- "date_range" => "all"
- }
-
- assert {:error, error} = Query.parse_and_build(site, :internal, params)
- assert error == "Metric `exit_rate` cannot be queried when filtering on event dimensions."
- end
-
- test "fails validation with event metrics", %{site: site} do
- params = %{
- "site_id" => site.domain,
- "metrics" => ["exit_rate", "pageviews"],
- "dimensions" => ["visit:exit_page"],
- "date_range" => "all"
- }
-
- assert {:error, error} = Query.parse_and_build(site, :internal, params)
-
- assert error ==
- "Event metric(s) `pageviews` cannot be queried along with session dimension(s) `visit:exit_page`"
- end
-
- test "passes validation", %{site: site} do
- params = %{
- "site_id" => site.domain,
- "metrics" => ["exit_rate"],
- "dimensions" => ["visit:exit_page"],
- "date_range" => "all"
- }
-
- assert {:ok, query} = Query.parse_and_build(site, :internal, params)
-
- assert_matches %Query{
- metrics: [:exit_rate],
- utc_time_range: ^@date_range_day,
- filters: [],
- dimensions: ["visit:exit_page"],
- order_by: nil,
- timezone: ^site.timezone,
- include: ^@default_include,
- pagination: %{limit: 10_000, offset: 0}
- } = query
- end
- end
-
describe "scroll_depth metric" do
test "fails validation on its own", %{site: site} do
params = %{
@@ -2153,7 +1867,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"date_range" => "all"
}
- assert {:error, error} = Query.parse_and_build(site, :internal, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"Metric `scroll_depth` can only be queried with event:page filters or dimensions."
@@ -2167,7 +1881,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["not", ["is", "event:page", ["/"]]]]
}
- assert {:error, error} = Query.parse_and_build(site, :internal, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"Metric `scroll_depth` can only be queried with event:page filters or dimensions."
@@ -2181,7 +1895,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "event:page", ["/"]]]
}
- assert {:ok, query} = Query.parse_and_build(site, :internal, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:scroll_depth],
@@ -2203,7 +1917,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => ["event:page"]
}
- assert {:ok, query} = Query.parse_and_build(site, :internal, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:scroll_depth],
@@ -2229,7 +1943,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "event:goal", ["Signup"]]]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:views_per_visit],
@@ -2256,7 +1970,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "event:page", ["/"]]]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "Metric `views_per_visit` cannot be queried with a filter on `event:page`."
end
@@ -2268,7 +1982,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => ["event:name"]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "Metric `views_per_visit` cannot be queried with `dimensions`."
end
end
@@ -2281,7 +1995,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"date_range" => "all"
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"Metric `time_on_page` can only be queried with event:page filters or dimensions."
@@ -2295,7 +2009,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => ["time", "event:page"]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:time_on_page],
@@ -2317,7 +2031,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "event:page", ["/"]]]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:time_on_page],
@@ -2341,7 +2055,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:error, error} = Query.parse_and_build(site, :internal, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"Metric `time_on_page` can only be queried with event:page filters or dimensions."
@@ -2363,7 +2077,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"date_range" => "all"
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:total_revenue, :average_revenue],
@@ -2398,7 +2112,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"date_range" => "all"
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"The owner of this site does not have access to the revenue metrics feature."
@@ -2423,7 +2137,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "event:goal", ["PurchaseUSD", "Signup", "Subscription"]]]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:total_revenue, :average_revenue],
@@ -2458,7 +2172,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "event:goal", ["Purchase", "Signup", "Subscription"]]]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:total_revenue, :average_revenue],
@@ -2493,7 +2207,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "event:goal", ["Signup"]]]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:total_revenue, :average_revenue],
@@ -2528,7 +2242,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => ["event:goal"]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:total_revenue, :average_revenue],
@@ -2565,7 +2279,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "event:goal", ["Purchase", "Signup", "Subscription"]]]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:total_revenue, :average_revenue],
@@ -2604,7 +2318,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "event:goal", ["Signup"]]]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:total_revenue, :average_revenue],
@@ -2636,7 +2350,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"date_range" => "all"
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"#/metrics/0: Invalid metric \"total_revenue\"\n#/metrics/1: Invalid metric \"average_revenue\""
@@ -2651,7 +2365,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => ["visit:device"]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:bounce_rate],
@@ -2673,7 +2387,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => ["event:props:foo"]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"Session metric(s) `bounce_rate` cannot be queried along with event dimension(s) `event:props:foo`"
@@ -2687,7 +2401,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => ["visit:exit_page"]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"Event metric(s) `events` cannot be queried along with session dimension(s) `visit:exit_page`"
@@ -2701,7 +2415,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"dimensions" => ["event:page"]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:bounce_rate],
@@ -2723,7 +2437,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "event:props:foo", ["(none)"]]]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:bounce_rate],
@@ -2760,7 +2474,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "Invalid filters. You can only use up to 10 segment filters in a query."
end
@@ -2786,7 +2500,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "segment", [segment.id]]]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "Invalid filters. Some segments don't exist or aren't accessible."
end
@@ -2814,7 +2528,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "segment", [segment.id]]]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"The owner of this site does not have access to the custom properties feature."
@@ -2851,7 +2565,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "segment", [segment.id]]]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error ==
"Invalid filters. Dimension `event:goal` can only be filtered at the top level."
@@ -2911,7 +2625,7 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors, :events],
@@ -2945,12 +2659,12 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
segment_from_dashboard =
insert(:segment,
- name: "A segment that contains :internal features",
+ name: "A segment that contains internal features",
type: :site,
owner: user,
site: site,
segment_data: %{
- "filters" => [["has_not_done", ["is", "event:goal", ["Signup"]]]]
+ "filters" => [["matches_wildcard", "event:page", ["/blog/**"]]]
}
)
@@ -2963,13 +2677,13 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
]
}
- assert {:ok, query} = Query.parse_and_build(site, :public, params)
+ assert {:ok, query} = Query.parse_and_build(site, params)
assert_matches %Query{
metrics: [:visitors, :events],
utc_time_range: ^@date_range_day,
filters: [
- [:has_not_done, [:is, "event:goal", ["Signup"]]]
+ [:matches_wildcard, "event:page", ["/blog/**"]]
],
dimensions: [],
order_by: nil,
@@ -2987,46 +2701,8 @@ defmodule Plausible.Stats.Query.QueryParseAndBuildTest do
"filters" => [["is", "segment", ["123"]]]
}
- assert {:error, error} = Query.parse_and_build(site, :public, params)
+ assert {:error, error} = Query.parse_and_build(site, params)
assert error == "Invalid filter '[\"is\", \"segment\", [\"123\"]]'."
end
end
-
- on_ee do
- describe "query.consolidated_site_ids" do
- test "is set to nil when site is regular", %{site: site} do
- params = %{
- "site_id" => site.domain,
- "metrics" => ["visitors"],
- "date_range" => "all"
- }
-
- {:ok, %{consolidated_site_ids: nil}} = Query.parse_and_build(site, :public, params)
- {:ok, %{consolidated_site_ids: nil}} = Query.parse_and_build(site, :internal, params)
- end
-
- test "is set to a list of site_ids when site is consolidated", %{site: site} do
- new_site(team: site.team)
- cv = new_consolidated_view(site.team)
-
- params = %{
- "site_id" => cv.domain,
- "metrics" => ["visitors"],
- "date_range" => "all"
- }
-
- assert {:ok, %{consolidated_site_ids: site_ids}} =
- Query.parse_and_build(cv, :public, params)
-
- assert length(site_ids) == 2
- assert site.id in site_ids
-
- assert {:ok, %{consolidated_site_ids: site_ids}} =
- Query.parse_and_build(cv, :internal, params)
-
- assert length(site_ids) == 2
- assert site.id in site_ids
- end
- end
- end
end
diff --git a/test/plausible/stats/query/query_result_test.exs b/test/plausible/stats/query/query_result_test.exs
index cee105f965..afe35cdf4b 100644
--- a/test/plausible/stats/query/query_result_test.exs
+++ b/test/plausible/stats/query/query_result_test.exs
@@ -15,11 +15,10 @@ defmodule Plausible.Stats.Query.QueryResultTest do
{:ok, site: site}
end
- test "query!/3 raises on error on site_id mismatch", %{site: site} do
+ test "parse_and_build!/2 raises on error on site_id mismatch", %{site: site} do
assert_raise FunctionClauseError, fn ->
Query.parse_and_build!(
site,
- :public,
%{
"site_id" => "different"
}
@@ -27,13 +26,12 @@ defmodule Plausible.Stats.Query.QueryResultTest do
end
end
- test "query!/3 raises on schema validation error", %{site: site} do
+ test "parse_and_build!/2 raises on schema validation error", %{site: site} do
assert_raise RuntimeError,
~s/Failed to build query: "#: Required properties metrics, date_range were not present."/,
fn ->
Query.parse_and_build!(
site,
- :public,
%{
"site_id" => site.domain
}
@@ -45,7 +43,6 @@ defmodule Plausible.Stats.Query.QueryResultTest do
query =
Query.parse_and_build!(
site,
- :public,
%{
"site_id" => site.domain,
"metrics" => ["pageviews"],
diff --git a/test/plausible/stats/table_decider_test.exs b/test/plausible/stats/table_decider_test.exs
index d30beb5669..03c446d91f 100644
--- a/test/plausible/stats/table_decider_test.exs
+++ b/test/plausible/stats/table_decider_test.exs
@@ -1,6 +1,6 @@
defmodule Plausible.Stats.TableDeciderTest do
use Plausible.DataCase, async: true
- alias Plausible.Stats.Query
+ alias Plausible.Stats.{Query, QueryBuilder, ParsedQueryParams}
import Plausible.Stats.TableDecider
@@ -14,12 +14,10 @@ defmodule Plausible.Stats.TableDeciderTest do
end
test "with nested filter" do
- assert not events_join_sessions?(
- make_query_full_filters([["not", ["is", "event:name", []]]])
- )
+ assert not events_join_sessions?(make_query_full_filters([[:not, [:is, "event:name", []]]]))
assert events_join_sessions?(
- make_query_full_filters([["not", ["is", "visit:exit_page", []]]])
+ make_query_full_filters([[:not, [:is, "visit:exit_page", []]]])
)
end
end
@@ -218,17 +216,25 @@ defmodule Plausible.Stats.TableDeciderTest do
end
defp make_query(filter_dimensions \\ [], dimensions \\ []) do
- Query.from(build(:site, id: :rand.uniform(100_000)), %{
- "filters" =>
- Enum.map(filter_dimensions, fn filter_dimension -> ["is", filter_dimension, []] end),
- "dimensions" => dimensions
+ site = build(:site, id: :rand.uniform(100_000))
+
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :all,
+ filters:
+ Enum.map(filter_dimensions, fn filter_dimension -> [:is, filter_dimension, []] end),
+ dimensions: dimensions
})
end
defp make_query_full_filters(filters) do
- Query.from(build(:site, id: :rand.uniform(100_000)), %{
- "dimensions" => [],
- "filters" => filters
+ site = build(:site, id: :rand.uniform(100_000))
+
+ QueryBuilder.build!(site, %ParsedQueryParams{
+ metrics: [:visitors],
+ input_date_range: :all,
+ dimensions: [],
+ filters: filters
})
end
end
diff --git a/test/plausible_web/controllers/api/internal_controller/segments_controller_test.exs b/test/plausible_web/controllers/api/internal_controller/segments_controller_test.exs
index 47658b8c81..1bd7ad7d2a 100644
--- a/test/plausible_web/controllers/api/internal_controller/segments_controller_test.exs
+++ b/test/plausible_web/controllers/api/internal_controller/segments_controller_test.exs
@@ -55,8 +55,7 @@ defmodule PlausibleWeb.Api.Internal.SegmentsControllerTest do
})
assert json_response(conn, 400) == %{
- "error" =>
- "segment_data #/filters/0: Invalid filter [\"is\", \"entry_page\", [\"/blog\"]]"
+ "error" => "segment_data Invalid filter '[\"is\", \"entry_page\", [\"/blog\"]]'."
}
end
@@ -175,7 +174,7 @@ defmodule PlausibleWeb.Api.Internal.SegmentsControllerTest do
for {filters, expected_error} <- [
{[], "segment_data property \"filters\" must be an array with at least one member"},
- {[["foo", "bar"]], "segment_data #/filters/0: Invalid filter [\"foo\", \"bar\"]"},
+ {[["foo", "bar"]], "segment_data Unknown operator for filter '[\"foo\", \"bar\"]'."},
{[["not", ["is", "visit:entry_page", ["/campaigns/:campaign_name"]]]],
"segment_data Invalid filters. Deep filters are not supported."},
{[