include.empty_metrics

Author: RobertJoonas

extra/lib/plausible/stats/goal/revenue.ex

@@ -56,6 +56,10 @@ defmodule Plausible.Stats.Goal.Revenue do
       query.revenue_currencies[:default] ||
         get_goal_dimension_revenue_currency(query, dimension_values)
 
+    format_revenue_metric(value, currency)
+  end
+
+  def format_revenue_metric(value, currency) do
     if currency do
       money = Money.new!(value || 0, currency)
 

lib/plausible/stats/metrics.ex

@@ -7,6 +7,8 @@ defmodule Plausible.Stats.Metrics do
 
   use Plausible
 
+  @revenue_metrics on_ee(do: Plausible.Stats.Goal.Revenue.revenue_metrics(), else: [])
+
   @all_metrics [
                  :visitors,
                  :visits,
@@ -21,22 +23,36 @@ defmodule Plausible.Stats.Metrics do
                  :time_on_page,
                  :percentage,
                  :scroll_depth
-               ] ++ on_ee(do: Plausible.Stats.Goal.Revenue.revenue_metrics(), else: [])
+               ] ++ @revenue_metrics
 
   @metric_mappings Enum.into(@all_metrics, %{}, fn metric -> {to_string(metric), metric} end)
 
   def metric?(value), do: Enum.member?(@all_metrics, value)
 
   on_ee do
-    def default_value(metric, query, dimensions)
-        when metric in [:average_revenue, :total_revenue],
-        do: Plausible.Stats.Goal.Revenue.format_revenue_metric(nil, query, dimensions)
+    # Default value in a goal breakdown depends on per-row currency
+    def default_value(metric, query, row_dimensions) when metric in @revenue_metrics do
+      Plausible.Stats.Goal.Revenue.format_revenue_metric(nil, query, row_dimensions)
+    end
+  end
+
+  def default_value(metric, _query, _dimensions), do: default_value(metric)
+
+  on_ee do
+    # When revenue metrics are queried without event:goal dimension,
+    # a single default currency is expected.
+    def default_value(metric, query) when metric in @revenue_metrics do
+      currency = query.revenue_currencies.default
+      Plausible.Stats.Goal.Revenue.format_revenue_metric(nil, currency)
+    end
   end
 
-  def default_value(:visit_duration, _query, _dimensions), do: nil
-  def default_value(:exit_rate, _query, _dimensions), do: nil
-  def default_value(:scroll_depth, _query, _dimensions), do: nil
-  def default_value(:time_on_page, _query, _dimensions), do: nil
+  def default_value(metric, _query), do: default_value(metric)
+
+  def default_value(:visit_duration), do: nil
+  def default_value(:exit_rate), do: nil
+  def default_value(:scroll_depth), do: nil
+  def default_value(:time_on_page), do: nil
 
   @float_metrics [
     :views_per_visit,
@@ -45,8 +61,8 @@ defmodule Plausible.Stats.Metrics do
     :conversion_rate,
     :group_conversion_rate
   ]
-  def default_value(metric, _query, _dimensions) when metric in @float_metrics, do: 0.0
-  def default_value(_metric, _query, _dimensions), do: 0
+  def default_value(metric) when metric in @float_metrics, do: 0.0
+  def default_value(_metric), do: 0
 
   def from_string!(str) do
     Map.fetch!(@metric_mappings, str)

lib/plausible/stats/query_include.ex

@@ -9,6 +9,9 @@ defmodule Plausible.Stats.QueryInclude do
             # breakdowns by multiple dimensions (time + non-time). Also, at this point it is
             # still unclear whether `time_labels` will stay in the public API or not.
             time_label_result_indices: false,
+            # Another flag to simplify frontend code by not having to repeat the logic defining
+            # default values for metrics (especially revenue metrics).
+            empty_metrics: false,
             present_index: false,
             partial_time_labels: false,
             total_rows: false,
@@ -27,6 +30,7 @@ defmodule Plausible.Stats.QueryInclude do
           imports_meta: boolean(),
           time_labels: boolean(),
           time_label_result_indices: boolean(),
+          empty_metrics: boolean(),
           present_index: boolean(),
           partial_time_labels: boolean(),
           total_rows: boolean(),

lib/plausible/stats/query_result.ex

@@ -58,6 +58,7 @@ defmodule Plausible.Stats.QueryResult do
     %{}
     |> add_imports_meta(runner.main_query)
     |> add_metric_warnings_meta(runner.main_query)
+    |> add_empty_metrics_meta(runner.main_query)
     |> add_time_labels_meta(runner)
     |> add_time_labels_result_indices_meta(runner)
     |> add_comparison_time_labels_meta(runner)
@@ -92,6 +93,18 @@ defmodule Plausible.Stats.QueryResult do
     end
   end
 
+  defp add_empty_metrics_meta(meta, query) do
+    if query.include.empty_metrics and "event:goal" not in query.dimensions do
+      Map.put(
+        meta,
+        :empty_metrics,
+        Enum.map(query.metrics, &Plausible.Stats.Metrics.default_value(&1, query))
+      )
+    else
+      meta
+    end
+  end
+
   defp add_time_labels_meta(meta, %QueryRunner{main_query: query}) do
     if query.include.time_labels do
       Map.put(meta, :time_labels, Plausible.Stats.Time.time_labels(query))

test/plausible/stats/query/query_test.exs

@@ -464,4 +464,68 @@ defmodule Plausible.Stats.QueryTest do
       assert [%{dimensions: ["2021-01-01 00:05:00"], metrics: [1, 50.0]}] = results
     end
   end
+
+  describe "include.empty_metrics" do
+    test "if not asked for, no empty_metrics are returned under meta", %{site: site} do
+      {:ok, query} =
+        QueryBuilder.build(site, %ParsedQueryParams{
+          metrics: [:visitors],
+          input_date_range: :all
+        })
+
+      %Stats.QueryResult{meta: meta} = Stats.query(site, query)
+
+      assert is_nil(meta[:empty_metrics])
+    end
+
+    test "for regular metrics", %{site: site} do
+      {:ok, query} =
+        QueryBuilder.build(site, %ParsedQueryParams{
+          metrics: [:visitors, :bounce_rate, :scroll_depth],
+          input_date_range: :all,
+          include: %QueryInclude{empty_metrics: true},
+          filters: [[:is, "event:page", ["/"]]]
+        })
+
+      %Stats.QueryResult{meta: meta} = Stats.query(site, query)
+
+      assert meta[:empty_metrics] == [0, 0.0, nil]
+    end
+
+    @tag :ee_only
+    test "for revenue metrics", %{site: site} do
+      insert(:goal, site: site, event_name: "Purchase", currency: "EUR")
+
+      {:ok, query} =
+        QueryBuilder.build(site, %ParsedQueryParams{
+          metrics: [:average_revenue, :total_revenue],
+          input_date_range: :all,
+          include: %QueryInclude{empty_metrics: true},
+          filters: [[:is, "event:goal", ["Purchase"]]]
+        })
+
+      %Stats.QueryResult{meta: meta} = Stats.query(site, query)
+
+      assert meta[:empty_metrics] == [
+               %{currency: :EUR, long: "€0.00", short: "€0.0", value: 0.0},
+               %{currency: :EUR, long: "€0.00", short: "€0.0", value: 0.0}
+             ]
+    end
+
+    test "is ignored when event:goal dimension used", %{site: site} do
+      insert(:goal, site: site, event_name: "Purchase", currency: "EUR")
+
+      {:ok, query} =
+        QueryBuilder.build(site, %ParsedQueryParams{
+          metrics: [:visitors, :average_revenue],
+          input_date_range: :all,
+          include: %QueryInclude{empty_metrics: true},
+          dimensions: ["event:goal"]
+        })
+
+      %Stats.QueryResult{meta: meta} = Stats.query(site, query)
+
+      assert is_nil(meta[:empty_metrics])
+    end
+  end
 end