Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.
TypeScript analyticsanalytics-dashboardclickhouseelixirgoogle-analyticsmarketingopen-source-analyticsphoenixplausible-analyticspostgresqlprivacyprivacy-friendlyself-hostedsimple-analyticsstatisticstailwindcssweb-analyticswebsite-analyticswebsite-statswebsite-tracking
Establish saved segments API (#4899)
Artur Pataf169f0caff77
diff --git a/lib/plausible/segment.ex b/lib/plausible/segment.exindex fc5809e15b..d85ba0a6f5 100644--- a/lib/plausible/segment.ex+++ b/lib/plausible/segment.ex@@ -44,14 +44,16 @@ defmodule Plausible.Segment do:owner_id])|> validate_required([:name, :segment_data, :site_id, :type, :owner_id])+ |> validate_length(:name, count: :bytes, min: 1, max: 255)|> foreign_key_constraint(:site_id)|> foreign_key_constraint(:owner_id)|> validate_only_known_properties_present()|> validate_segment_data_filters()|> validate_segment_data_labels()+ |> validate_json_byte_length(:segment_data, max: 5 * 1024)end- defp validate_only_known_properties_present(changeset) do+ defp validate_only_known_properties_present(%Ecto.Changeset{} = changeset) docase get_field(changeset, :segment_data) dosegment_data when is_map(segment_data) ->if Enum.any?(Map.keys(segment_data) -- ["filters", "labels"]) do@@ -69,7 +71,7 @@ defmodule Plausible.Segment doendend- defp validate_segment_data_filters(changeset) do+ defp validate_segment_data_filters(%Ecto.Changeset{} = changeset) docase get_field(changeset, :segment_data) do%{"filters" => filters} when is_list(filters) and length(filters) > 0 ->changeset@@ -83,7 +85,7 @@ defmodule Plausible.Segment doendend- defp validate_segment_data_labels(changeset) do+ defp validate_segment_data_labels(%Ecto.Changeset{} = changeset) docase get_field(changeset, :segment_data) do%{"labels" => labels} when not is_map(labels) ->add_error(changeset, :segment_data, "property \"labels\" must be map or nil")@@ -92,4 +94,112 @@ defmodule Plausible.Segment dochangesetendend++ defp validate_json_byte_length(%Ecto.Changeset{} = changeset, field_key, opts) do+ field = get_field(changeset, field_key)+ max = Keyword.get(opts, :max, 0)++ if :erlang.byte_size(Jason.encode!(field)) > max do+ add_error(changeset, field_key, "should be at most %{count} byte(s)", count: max)+ else+ changeset+ end+ end++ def validate_segment_data_if_exists(+ %Plausible.Site{} = _site,+ nil = _segment_data,+ _restricted_depth?+ ),+ 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+ end++ @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.+ """+ def build_naive_query_from_segment_data(%Plausible.Site{} = site, filters),+ do:+ Plausible.Stats.Query.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,+ collecting filter related errors into a list.+ 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}}+ else+ {:error, 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++ defp maybe_validate_filters_depth(filters, true) do+ if Enum.all?(filters, &dashboard_compatible_filter?/1) do+ :ok+ else+ :error_deep_filters_not_supported+ end+ end++ defp dashboard_compatible_filter?(filter) do+ is_list(filter) and length(filter) === 3 and+ is_atom(Enum.at(filter, 0)) and+ is_binary(Enum.at(filter, 1)) and+ is_list(Enum.at(filter, 2))+ endenddiff --git a/lib/plausible_web/controllers/api/helpers.ex b/lib/plausible_web/controllers/api/helpers.exindex 1c3a9e98bc..109e3a1263 100644--- a/lib/plausible_web/controllers/api/helpers.ex+++ b/lib/plausible_web/controllers/api/helpers.ex@@ -8,6 +8,13 @@ defmodule PlausibleWeb.Api.Helpers do|> halt()end+ def not_enough_permissions(conn, msg) do+ conn+ |> put_status(403)+ |> Phoenix.Controller.json(%{error: msg})+ |> halt()+ end+def bad_request(conn, msg) doconn|> put_status(400)diff --git a/lib/plausible_web/controllers/api/internal/segments_controller.ex b/lib/plausible_web/controllers/api/internal/segments_controller.exnew file mode 100644index 0000000000..bcc65b972c--- /dev/null+++ b/lib/plausible_web/controllers/api/internal/segments_controller.ex@@ -0,0 +1,333 @@+defmodule PlausibleWeb.Api.Internal.SegmentsController do+ use Plausible+ use PlausibleWeb, :controller+ use Plausible.Repo+ use PlausibleWeb.Plugs.ErrorHandler+ alias PlausibleWeb.Api.Helpers, as: H++ @fields_in_index_query [+ :id,+ :name,+ :type,+ :inserted_at,+ :updated_at,+ :owner_id+ ]++ def get_all_segments(+ %Plug.Conn{+ assigns: %{+ site: site,+ site_role: site_role,+ current_user: current_user+ }+ } = conn,+ %{} = _params+ ) do+ site_segments_available? =+ site_segments_available?(site)++ cond do+ site_role in roles_with_personal_segments() and+ site_segments_available? ->+ result =+ Repo.all(+ get_personal_and_site_segments_query(current_user.id, site.id, @fields_in_index_query)+ )++ json(conn, result)++ site_role in roles_with_personal_segments() ->+ result =+ Repo.all(+ get_personal_segments_only_query(current_user.id, site.id, @fields_in_index_query)+ )++ json(conn, result)++ site_role in [:public] and site_segments_available? ->+ result =+ Repo.all(+ get_site_segments_only_query(+ site.id,+ @fields_in_index_query -- [:owner_id]+ )+ )++ json(conn, result)++ true ->+ H.not_enough_permissions(conn, "Not enough permissions to get segments")+ end+ end++ def get_segment(+ %Plug.Conn{+ assigns: %{+ site: site,+ current_user: current_user,+ site_role: site_role+ }+ } = conn,+ %{} = params+ ) do+ segment_id = normalize_segment_id_param(params["segment_id"])++ if site_role in roles_with_personal_segments() do+ result = get_one_segment(current_user.id, site.id, segment_id)++ case result do+ nil -> H.not_found(conn, "Segment not found with ID #{inspect(params["segment_id"])}")+ result when is_map(result) -> json(conn, result)+ end+ else+ H.not_enough_permissions(conn, "Not enough permissions to get segment data")+ end+ end++ def create_segment(+ %Plug.Conn{+ assigns: %{+ site: site,+ site_role: site_role+ }+ } = conn,+ %{} = params+ ) do+ site_segments_available? = site_segments_available?(site)++ cond do+ params["type"] == Atom.to_string(:personal) and+ site_role in roles_with_personal_segments() ->+ do_insert_segment(conn, params)++ params["type"] == Atom.to_string(:site) and site_segments_available? and+ site_role in roles_with_maybe_site_segments() ->+ do_insert_segment(conn, params)++ true ->+ H.not_enough_permissions(conn, "Not enough permissions to create segment")+ end+ end++ def create_segment(%Plug.Conn{} = conn, _params), do: H.bad_request(conn, "Invalid request")++ def update_segment(+ %Plug.Conn{+ assigns: %{+ site: site,+ current_user: %{id: user_id},+ site_role: site_role+ }+ } =+ conn,+ %{} = params+ ) do+ site_segments_available? = site_segments_available?(site)++ segment_id = normalize_segment_id_param(params["segment_id"])++ existing_segment = get_one_segment(user_id, site.id, segment_id)++ cond do+ is_nil(existing_segment) ->+ H.not_found(conn, "Segment not found with ID #{inspect(params["segment_id"])}")++ existing_segment.type == :personal and params["type"] != "site" and+ site_role in roles_with_personal_segments() ->+ do_update_segment(conn, params, existing_segment, user_id)++ existing_segment.type == :personal and params["type"] == "site" and site_segments_available? and+ site_role in roles_with_maybe_site_segments() ->+ do_update_segment(conn, params, existing_segment, user_id)++ existing_segment.type == :site and site_segments_available? and+ site_role in roles_with_maybe_site_segments() ->+ do_update_segment(conn, params, existing_segment, user_id)++ true ->+ H.not_enough_permissions(conn, "Not enough permissions to edit segment")+ end+ end++ def update_segment(%Plug.Conn{} = conn, _params), do: H.bad_request(conn, "Invalid request")++ def delete_segment(+ %Plug.Conn{+ assigns: %{+ site: site,+ current_user: %{id: user_id},+ site_role: site_role+ }+ } =+ conn,+ %{} = params+ ) do+ site_segments_available? = site_segments_available?(site)++ segment_id = normalize_segment_id_param(params["segment_id"])++ existing_segment = get_one_segment(user_id, site.id, segment_id)++ cond do+ is_nil(existing_segment) ->+ H.not_found(conn, "Segment not found with ID #{inspect(params["segment_id"])}")++ existing_segment.type == :personal and+ site_role in roles_with_personal_segments() ->+ do_delete_segment(conn, existing_segment)++ existing_segment.type == :site and+ site_segments_available? and+ site_role in roles_with_maybe_site_segments() ->+ do_delete_segment(conn, existing_segment)++ true ->+ H.not_enough_permissions(conn, "Not enough permissions to delete segment")+ end+ end++ def delete_segment(%Plug.Conn{} = conn, _params), do: H.bad_request(conn, "Invalid request")++ @spec get_site_segments_only_query(pos_integer(), list(atom())) :: Ecto.Query.t()+ defp get_site_segments_only_query(site_id, fields) do+ from(segment in Plausible.Segment,+ select: ^fields,+ where: segment.site_id == ^site_id,+ where: segment.type == :site,+ order_by: [desc: segment.updated_at, desc: segment.id]+ )+ end++ @spec get_personal_segments_only_query(pos_integer(), pos_integer(), list(atom())) ::+ Ecto.Query.t()+ defp get_personal_segments_only_query(user_id, site_id, fields) do+ from(segment in Plausible.Segment,+ select: ^fields,+ where: segment.site_id == ^site_id,+ where: segment.type == :personal and segment.owner_id == ^user_id,+ order_by: [desc: segment.updated_at, desc: segment.id]+ )+ end++ @spec get_personal_and_site_segments_query(pos_integer(), pos_integer(), list(atom())) ::+ Ecto.Query.t()+ defp get_personal_and_site_segments_query(user_id, site_id, fields) do+ from(segment in Plausible.Segment,+ select: ^fields,+ where: segment.site_id == ^site_id,+ where:+ segment.type == :site or (segment.type == :personal and segment.owner_id == ^user_id),+ order_by: [desc: segment.updated_at, desc: segment.id]+ )+ end++ @spec normalize_segment_id_param(any()) :: nil | pos_integer()+ defp normalize_segment_id_param(input) do+ case Integer.parse(input) do+ {int_value, ""} when int_value > 0 -> int_value+ _ -> nil+ end+ end++ defp get_one_segment(_user_id, _site_id, nil) do+ nil+ end++ defp get_one_segment(user_id, site_id, segment_id) do+ query =+ from(segment in Plausible.Segment,+ where: segment.site_id == ^site_id,+ where: segment.id == ^segment_id,+ where: segment.type == :site or segment.owner_id == ^user_id+ )++ Repo.one(query)+ end++ defp do_insert_segment(+ %Plug.Conn{+ assigns: %{+ site: site,+ current_user: %{id: user_id}+ }+ } = conn,+ %{} = params+ ) do+ segment_definition = Map.merge(params, %{"site_id" => site.id, "owner_id" => user_id})++ with %{valid?: true} = changeset <-+ Plausible.Segment.changeset(+ %Plausible.Segment{},+ segment_definition+ ),+ :ok <- Plausible.Segment.validate_segment_data(site, params["segment_data"], true) do+ segment = Repo.insert!(changeset)+ json(conn, segment)+ else+ %{valid?: false, errors: errors} ->+ conn+ |> put_status(400)+ |> json(%{+ errors: Enum.map(errors, fn {field_key, {message, _}} -> [field_key, message] end)+ })++ {:error, {:invalid_filters, message}} ->+ conn |> put_status(400) |> json(%{errors: [["segment_data", message]]})+ end+ end++ defp do_update_segment(+ %Plug.Conn{} = conn,+ %{} = params,+ %Plausible.Segment{} = existing_segment,+ owner_override+ ) do+ partial_segment_definition = Map.merge(params, %{"owner_id" => owner_override})++ with %{valid?: true} = changeset <-+ Plausible.Segment.changeset(+ existing_segment,+ partial_segment_definition+ ),+ :ok <-+ Plausible.Segment.validate_segment_data_if_exists(+ conn.assigns.site,+ params["segment_data"],+ true+ ) do+ json(+ conn,+ Repo.update!(+ changeset,+ returning: true+ )+ )+ else+ %{valid?: false, errors: errors} ->+ conn+ |> put_status(400)+ |> json(%{+ errors:+ Enum.map(errors, fn {field_key, {message, opts}} -> [field_key, message, opts] end)+ })++ {:error, {:invalid_filters, message}} ->+ conn |> put_status(400) |> json(%{errors: [["segment_data", message, []]]})+ end+ end++ defp do_delete_segment(+ %Plug.Conn{} = conn,+ %Plausible.Segment{} = existing_segment+ ) do+ Repo.delete!(existing_segment)+ json(conn, existing_segment)+ end++ defp roles_with_personal_segments(), do: [:viewer, :editor, :admin, :owner, :super_admin]+ defp roles_with_maybe_site_segments(), do: [:editor, :admin, :owner, :super_admin]++ defp site_segments_available?(site),+ do: Plausible.Billing.Feature.Props.check_availability(site.team) == :ok+enddiff --git a/lib/plausible_web/plugs/feature_flag_check_plug.ex b/lib/plausible_web/plugs/feature_flag_check_plug.exnew file mode 100644index 0000000000..75698da084--- /dev/null+++ b/lib/plausible_web/plugs/feature_flag_check_plug.ex@@ -0,0 +1,28 @@+defmodule PlausibleWeb.Plugs.FeatureFlagCheckPlug do+ @moduledoc """+ plug(PlausibleWeb.Plugs.FeatureFlagCheckPlug, [:flag_foo, :flag_bar])+ to halt any API connections with 404 where conn.assigns.current_user or conn.assigns.site+ don't have both feature flags true.+ """+ def init(feature_flags) when is_list(feature_flags) and length(feature_flags) > 0 do+ feature_flags+ end++ def init(_),+ do: raise(ArgumentError, "The first argument must be a non-empty list of feature flags")++ def call(%Plug.Conn{} = conn, flags) do+ if validate(conn.assigns.current_user, conn.assigns.site, flags) do+ conn+ else+ PlausibleWeb.Api.Helpers.not_found(conn, "Not found")+ end+ end++ defp validate(current_user, site, flags),+ do:+ Enum.all?(flags, fn flag ->+ FunWithFlags.enabled?(flag, for: current_user) ||+ FunWithFlags.enabled?(flag, for: site)+ end)+enddiff --git a/lib/plausible_web/router.ex b/lib/plausible_web/router.exindex c1006ce232..c457d42254 100644--- a/lib/plausible_web/router.ex+++ b/lib/plausible_web/router.ex@@ -120,16 +120,16 @@ defmodule PlausibleWeb.Router doscope [] dopipe_through :browser- get("/basic", TestController, :browser)- get("/:domain/shared-link/:slug", TestController, :browser)- get("/:domain/with-domain", TestController, :browser)+ get("/basic", TestController, :browser_basic)+ get("/:domain/shared-link/:slug", TestController, :browser_basic)+ get("/:domain/with-domain", TestController, :browser_basic)endscope [] dopipe_through :api- get("/api-basic", TestController, :api)- get("/:domain/api-with-domain", TestController, :api)+ get("/api-basic", TestController, :api_basic)+ get("/:domain/api-with-domain", TestController, :api_basic)endendend@@ -180,42 +180,56 @@ defmodule PlausibleWeb.Router doendend- scope "/api/stats", PlausibleWeb.Api do+ scope "/api" dopipe_through :internal_stats_api- on_ee do- get "/:domain/funnels/:id", StatsController, :funnel+ scope "/stats", PlausibleWeb.Api do+ on_ee do+ get "/:domain/funnels/:id", StatsController, :funnel+ end++ get "/:domain/current-visitors", StatsController, :current_visitors+ get "/:domain/main-graph", StatsController, :main_graph+ get "/:domain/top-stats", StatsController, :top_stats+ get "/:domain/sources", StatsController, :sources+ get "/:domain/channels", StatsController, :channels+ get "/:domain/utm_mediums", StatsController, :utm_mediums+ get "/:domain/utm_sources", StatsController, :utm_sources+ get "/:domain/utm_campaigns", StatsController, :utm_campaigns+ get "/:domain/utm_contents", StatsController, :utm_contents+ get "/:domain/utm_terms", StatsController, :utm_terms+ get "/:domain/referrers/:referrer", StatsController, :referrer_drilldown+ get "/:domain/pages", StatsController, :pages+ get "/:domain/entry-pages", StatsController, :entry_pages+ get "/:domain/exit-pages", StatsController, :exit_pages+ get "/:domain/countries", StatsController, :countries+ get "/:domain/regions", StatsController, :regions+ get "/:domain/cities", StatsController, :cities+ get "/:domain/browsers", StatsController, :browsers+ get "/:domain/browser-versions", StatsController, :browser_versions+ get "/:domain/operating-systems", StatsController, :operating_systems+ get "/:domain/operating-system-versions", StatsController, :operating_system_versions+ get "/:domain/screen-sizes", StatsController, :screen_sizes+ get "/:domain/conversions", StatsController, :conversions+ get "/:domain/custom-prop-values/:prop_key", StatsController, :custom_prop_values+ get "/:domain/suggestions/:filter_name", StatsController, :filter_suggestions++ get "/:domain/suggestions/custom-prop-values/:prop_key",+ StatsController,+ :custom_prop_value_filter_suggestionsend- get "/:domain/current-visitors", StatsController, :current_visitors- get "/:domain/main-graph", StatsController, :main_graph- get "/:domain/top-stats", StatsController, :top_stats- get "/:domain/sources", StatsController, :sources- get "/:domain/channels", StatsController, :channels- get "/:domain/utm_mediums", StatsController, :utm_mediums- get "/:domain/utm_sources", StatsController, :utm_sources- get "/:domain/utm_campaigns", StatsController, :utm_campaigns- get "/:domain/utm_contents", StatsController, :utm_contents- get "/:domain/utm_terms", StatsController, :utm_terms- get "/:domain/referrers/:referrer", StatsController, :referrer_drilldown- get "/:domain/pages", StatsController, :pages- get "/:domain/entry-pages", StatsController, :entry_pages- get "/:domain/exit-pages", StatsController, :exit_pages- get "/:domain/countries", StatsController, :countries- get "/:domain/regions", StatsController, :regions- get "/:domain/cities", StatsController, :cities- get "/:domain/browsers", StatsController, :browsers- get "/:domain/browser-versions", StatsController, :browser_versions- get "/:domain/operating-systems", StatsController, :operating_systems- get "/:domain/operating-system-versions", StatsController, :operating_system_versions- get "/:domain/screen-sizes", StatsController, :screen_sizes- get "/:domain/conversions", StatsController, :conversions- get "/:domain/custom-prop-values/:prop_key", StatsController, :custom_prop_values- get "/:domain/suggestions/:filter_name", StatsController, :filter_suggestions-- get "/:domain/suggestions/custom-prop-values/:prop_key",- StatsController,- :custom_prop_value_filter_suggestions+ scope "/:domain/segments", PlausibleWeb.Api.Internal do+ pipeline :segments_endpoints,+ do: plug(PlausibleWeb.Plugs.FeatureFlagCheckPlug, [:saved_segments])++ pipe_through :segments_endpoints+ get "/", SegmentsController, :get_all_segments+ post "/", SegmentsController, :create_segment+ get "/:segment_id", SegmentsController, :get_segment+ patch "/:segment_id", SegmentsController, :update_segment+ delete "/:segment_id", SegmentsController, :delete_segment+ endendscope "/api/v1/stats", PlausibleWeb.Api, assigns: %{api_scope: "stats:read:*"} dodiff --git a/test/plausible/segment_schema_test.exs b/test/plausible/segment_schema_test.exsindex 93622b631e..104fbf160c 100644--- a/test/plausible/segment_schema_test.exs+++ b/test/plausible/segment_schema_test.exs@@ -1,5 +1,6 @@defmodule Plausible.SegmentSchemaTest douse ExUnit.Case+ doctest Plausible.Segment, import: truesetup dosegment = %Plausible.Segment{@@ -36,6 +37,33 @@ defmodule Plausible.SegmentSchemaTest do]end+ test "changeset forbids too long name", %{segment: valid_segment} do+ assert Plausible.Segment.changeset(+ valid_segment,+ %{+ name: String.duplicate("a", 256)+ }+ ).errors == [+ name:+ {"should be at most %{count} byte(s)",+ [{:count, 255}, {:validation, :length}, {:kind, :max}, {:type, :binary}]}+ ]+ end++ test "changeset forbids too large segment_data", %{segment: valid_segment} do+ assert Plausible.Segment.changeset(+ valid_segment,+ %{+ segment_data:+ Jason.decode!(+ ~s({"filters": ["is", "visit:exit_page", [#{Enum.map_join(1..(5 * 1024), ",", fn i -> "#{i}" end)}]]})+ )+ }+ ).errors == [+ segment_data: {"should be at most %{count} byte(s)", [{:count, 5120}]}+ ]+ end+test "changeset allows setting nil owner_id to a user id (to be able to recover dangling site segments)",%{segment: valid_segment} doassert Plausible.Segment.changeset(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.exsnew file mode 100644index 0000000000..5d355c13cd--- /dev/null+++ b/test/plausible_web/controllers/api/internal_controller/segments_controller_test.exs@@ -0,0 +1,579 @@+defmodule PlausibleWeb.Api.Internal.SegmentsControllerTest do+ use PlausibleWeb.ConnCase, async: true+ use Plausible.Repo+ use Plausible.Teams.Test++ describe "GET /api/:domain/segments" do+ setup [:create_user, :log_in, :create_site]++ test "returns empty list when no segments", %{conn: conn, site: site} do+ conn =+ get(conn, "/api/#{site.domain}/segments")++ assert json_response(conn, 200) == []+ end++ test "returns site segments list when looking at a public dashboard", %{conn: conn} do+ other_user = new_user()+ site = new_site(owner: other_user, public: true)++ site_segments =+ insert_list(2, :segment,+ site: site,+ owner: other_user,+ type: :site,+ name: "other site segment"+ )++ insert_list(10, :segment,+ site: site,+ owner: other_user,+ type: :personal,+ name: "other user personal segment"+ )++ conn = get(conn, "/api/#{site.domain}/segments")++ assert json_response(conn, 200) ==+ Enum.reverse(+ Enum.map(site_segments, fn s ->+ %{+ "id" => s.id,+ "name" => s.name,+ "type" => Atom.to_string(s.type),+ "owner_id" => nil,+ "inserted_at" => NaiveDateTime.to_iso8601(s.inserted_at),+ "updated_at" => NaiveDateTime.to_iso8601(s.updated_at),+ "segment_data" => nil+ }+ end)+ )+ end++ test "forbids owners on growth plan from seeing site segments", %{+ conn: conn,+ user: user,+ site: site+ } do+ user |> subscribe_to_growth_plan()++ insert_list(2, :segment,+ site: site,+ owner: user,+ type: :site,+ name: "site segment"+ )++ conn =+ get(conn, "/api/#{site.domain}/segments")++ assert json_response(conn, 200) == []+ end++ for role <- [:viewer, :owner] do+ test "returns list with personal and site segments for #{role}, avoiding segments from other site",+ %{conn: conn, user: user, site: site} do+ other_user = new_user()+ other_site = new_site(owner: other_user, team: team_of(user))++ insert_list(2, :segment,+ site: other_site,+ owner: user,+ type: :site,+ name: "other site segment"+ )++ insert_list(10, :segment,+ site: site,+ owner: other_user,+ type: :personal,+ name: "other user personal segment"+ )++ personal_segment =+ insert(:segment,+ site: site,+ owner: user,+ type: :personal,+ name: "a personal segment"+ )++ emea_site_segment =+ insert(:segment,+ site: site,+ owner: other_user,+ type: :site,+ name: "EMEA region"+ )++ apac_site_segment =+ insert(:segment,+ site: site,+ owner: user,+ type: :site,+ name: "APAC region"+ )++ conn =+ get(conn, "/api/#{site.domain}/segments")++ assert json_response(conn, 200) ==+ Enum.map([apac_site_segment, emea_site_segment, personal_segment], fn s ->+ %{+ "id" => s.id,+ "name" => s.name,+ "type" => Atom.to_string(s.type),+ "owner_id" => s.owner_id,+ "inserted_at" => NaiveDateTime.to_iso8601(s.inserted_at),+ "updated_at" => NaiveDateTime.to_iso8601(s.updated_at),+ "segment_data" => nil+ }+ end)+ end+ end+ end++ describe "GET /api/:domain/segments/:segment_id" do+ setup [:create_user, :create_site, :log_in]++ test "serves 404 when invalid segment key used", %{conn: conn, site: site} do+ conn =+ get(conn, "/api/#{site.domain}/segments/any-id")++ assert json_response(conn, 404) == %{"error" => "Segment not found with ID \"any-id\""}+ end++ test "serves 404 when no segment found", %{conn: conn, site: site} do+ conn =+ get(conn, "/api/#{site.domain}/segments/100100")++ assert json_response(conn, 404) == %{"error" => "Segment not found with ID \"100100\""}+ end++ test "serves 404 when segment is for another site", %{conn: conn, site: site, user: user} do+ other_site = new_site(owner: user)++ segment =+ insert(:segment,+ site: other_site,+ owner: user,+ type: :site,+ name: "any"+ )++ conn =+ get(conn, "/api/#{site.domain}/segments/#{segment.id}")++ assert json_response(conn, 404) == %{+ "error" => "Segment not found with ID \"#{segment.id}\""+ }+ end++ test "serves 404 for viewing contents of site segments for viewers of public dashboards",+ %{+ conn: conn+ } do+ site = new_site(public: true)+ other_user = add_guest(site, user: new_user(), role: :editor)++ segment =+ insert(:segment,+ type: :site,+ owner: other_user,+ site: site,+ name: "any"+ )++ conn =+ get(conn, "/api/#{site.domain}/segments/#{segment.id}")++ assert json_response(conn, 403) == %{+ "error" => "Not enough permissions to get segment data"+ }+ end++ test "serves 404 when user is not the segment owner and segment is personal",+ %{+ conn: conn,+ site: site+ } do+ other_user = add_guest(site, role: :editor)++ segment =+ insert(:segment,+ type: :personal,+ owner: other_user,+ site: site,+ name: "any"+ )++ conn =+ get(conn, "/api/#{site.domain}/segments/#{segment.id}")++ assert json_response(conn, 404) == %{+ "error" => "Segment not found with ID \"#{segment.id}\""+ }+ end++ test "serves 200 with segment when user is not the segment owner and segment is not personal",+ %{+ conn: conn,+ site: site+ } do+ other_user = add_guest(site, role: :editor)++ segment =+ insert(:segment,+ type: :site,+ owner: other_user,+ site: site,+ name: "any",+ inserted_at: "2024-09-01T10:00:00",+ updated_at: "2024-09-01T10:00:00"+ )++ conn =+ get(conn, "/api/#{site.domain}/segments/#{segment.id}")++ assert json_response(conn, 200) == %{+ "id" => segment.id,+ "owner_id" => other_user.id,+ "name" => segment.name,+ "type" => Atom.to_string(segment.type),+ "segment_data" => segment.segment_data,+ "inserted_at" => NaiveDateTime.to_iso8601(segment.inserted_at),+ "updated_at" => NaiveDateTime.to_iso8601(segment.updated_at)+ }+ end++ test "serves 200 with segment when user is segment owner", %{+ conn: conn,+ site: site,+ user: user+ } do+ segment =+ insert(:segment,+ site: site,+ name: "any",+ owner: user,+ type: :personal+ )++ conn =+ get(conn, "/api/#{site.domain}/segments/#{segment.id}")++ assert json_response(conn, 200) == %{+ "id" => segment.id,+ "owner_id" => user.id,+ "name" => segment.name,+ "type" => Atom.to_string(segment.type),+ "segment_data" => segment.segment_data,+ "inserted_at" => NaiveDateTime.to_iso8601(segment.inserted_at),+ "updated_at" => NaiveDateTime.to_iso8601(segment.updated_at)+ }+ end+ end++ describe "POST /api/:domain/segments" do+ setup [:create_user, :log_in, :create_site]++ test "forbids viewers from creating site segments", %{conn: conn, user: user} do+ site = new_site()+ add_guest(site, user: user, role: :viewer)++ conn =+ post(conn, "/api/#{site.domain}/segments", %{+ "type" => "site",+ "segment_data" => %{"filters" => [["is", "visit:entry_page", ["/blog"]]]},+ "name" => "any name"+ })++ assert json_response(conn, 403) == %{+ "error" => "Not enough permissions to create segment"+ }+ end++ test "forbids owners on growth plan from creating site segments", %{+ conn: conn,+ user: user,+ site: site+ } do+ user |> subscribe_to_growth_plan()++ conn =+ post(conn, "/api/#{site.domain}/segments", %{+ "type" => "site",+ "segment_data" => %{"filters" => [["is", "visit:entry_page", ["/blog"]]]},+ "name" => "any name"+ })++ assert json_response(conn, 403) == %{+ "error" => "Not enough permissions to create segment"+ }+ end++ test "forbids users from creating segments with invalid filters",+ %{+ conn: conn,+ site: site+ } do+ conn =+ post(conn, "/api/#{site.domain}/segments", %{+ "type" => "site",+ "segment_data" => %{+ "filters" => [["is", "entry_page", ["/blog"]]]+ },+ "name" => "any name"+ })++ assert json_response(conn, 400) == %{+ "errors" => [+ [+ "segment_data",+ "#/filters/0: Invalid filter [\"is\", \"entry_page\", [\"/blog\"]]"+ ]+ ]+ }+ end++ for %{role: role, type: type} <- [+ %{role: :viewer, type: :personal},+ %{role: :editor, type: :personal},+ %{role: :editor, type: :site}+ ] do+ test "#{role} can create segment with type \"#{type}\" successfully",+ %{conn: conn, user: user} do+ site = new_site()+ add_guest(site, user: user, role: unquote(role))++ response =+ post(conn, "/api/#{site.domain}/segments", %{+ "name" => "Some segment",+ "type" => "#{unquote(type)}",+ "segment_data" => %{"filters" => [["is", "visit:entry_page", ["/blog"]]]}+ })+ |> json_response(200)++ assert %{+ "name" => "Some segment",+ "type" => "#{unquote(type)}",+ "segment_data" => %{"filters" => [["is", "visit:entry_page", ["/blog"]]]},+ "owner_id" => user.id+ } == Map.drop(response, ["id", "inserted_at", "updated_at"])++ assert is_integer(response["id"])+ assert is_binary(response["inserted_at"])+ assert is_binary(response["updated_at"])+ assert response["inserted_at"] == response["updated_at"]++ verify_segment_in_db(%Plausible.Segment{+ id: response["id"],+ name: response["name"],+ type: String.to_existing_atom(response["type"]),+ segment_data: response["segment_data"],+ owner_id: response["owner_id"],+ site_id: site.id,+ inserted_at: NaiveDateTime.from_iso8601!(response["inserted_at"]),+ updated_at: NaiveDateTime.from_iso8601!(response["updated_at"])+ })+ end+ end+ end++ describe "PATCH /api/:domain/segments/:segment_id" do+ setup [:create_user, :create_site, :log_in]++ for {current_type, patch_type} <- [+ {:personal, :site},+ {:site, :personal}+ ] do+ test "prevents viewers from updating segments with current type #{current_type} with #{patch_type}",+ %{+ conn: conn,+ user: user+ } do+ site = new_site()+ add_guest(site, user: user, role: :viewer)++ %{id: segment_id} =+ insert(:segment,+ site: site,+ name: "any",+ type: unquote(current_type),+ owner: user+ )++ conn =+ patch(conn, "/api/#{site.domain}/segments/#{segment_id}", %{+ "name" => "updated name",+ "type" => "#{unquote(patch_type)}"+ })++ assert json_response(conn, 403) == %{+ "error" => "Not enough permissions to edit segment"+ }+ end+ end++ for {filters, expected_errors} <- [+ {[],+ [+ [+ "segment_data",+ "property \"filters\" must be an array with at least one member",+ []+ ]+ ]},+ {[["foo", "bar"]],+ [["segment_data", "#/filters/0: Invalid filter [\"foo\", \"bar\"]", []]]},+ {[["not", ["is", "visit:entry_page", ["/campaigns/:campaign_name"]]]],+ [["segment_data", "Invalid filters. Deep filters are not supported.", []]]},+ {[+ [+ "or",+ [+ ["is", "event:goal", ["any goal"]],+ ["is", "visit:entry_page", ["/campaigns/:campaign_name"]]+ ]+ ]+ ],+ [+ [+ "segment_data",+ "Invalid filters. Dimension `event:goal` can only be filtered at the top level.",+ []+ ]+ ]}+ ] do+ test "prevents owners from updating segments to invalid filters #{inspect(filters)} with error 400",+ %{+ conn: conn,+ user: user,+ site: site+ } do+ segment =+ insert(:segment,+ site: site,+ name: "any name",+ type: :personal,+ owner: user+ )++ conn =+ patch(conn, "/api/#{site.domain}/segments/#{segment.id}", %{+ "segment_data" => %{"filters" => unquote(filters)}+ })++ assert json_response(conn, 400) == %{+ "errors" => unquote(expected_errors)+ }+ end+ end++ test "editors can update a segment", %{conn: conn, user: user} do+ site = new_site()+ add_guest(site, user: user, role: :editor)++ segment =+ insert(:segment,+ site: site,+ name: "original name",+ type: :site,+ owner: user,+ inserted_at: "2024-09-01T10:00:00",+ updated_at: "2024-09-01T10:00:00"+ )++ response =+ patch(conn, "/api/#{site.domain}/segments/#{segment.id}", %{+ "name" => "updated name",+ "type" => Atom.to_string(:personal)+ })+ |> json_response(200)++ assert %{+ "id" => segment.id,+ "name" => "updated name",+ "type" => Atom.to_string(:personal),+ "owner_id" => user.id,+ "segment_data" => segment.segment_data,+ "inserted_at" => NaiveDateTime.to_iso8601(segment.inserted_at)+ } == Map.drop(response, ["updated_at"])++ assert response["updated_at"] > response["inserted_at"]+ end+ end++ describe "DELETE /api/:domain/segments/:segment_id" do+ setup [:create_user, :create_site, :log_in]++ test "forbids viewers from deleting site segments", %{conn: conn, user: user} do+ site = new_site()+ add_guest(site, user: user, role: :viewer)++ segment =+ insert(:segment,+ site: site,+ name: "any",+ type: :site,+ owner_id: user.id+ )++ conn =+ delete(conn, "/api/#{site.domain}/segments/#{segment.id}")++ assert json_response(conn, 403) == %{+ "error" => "Not enough permissions to delete segment"+ }++ verify_segment_in_db(segment)+ end++ for %{role: role, type: type} <- [+ %{role: :viewer, type: :personal},+ %{role: :editor, type: :personal},+ %{role: :editor, type: :site}+ ] do+ test "#{role} can delete segment with type \"#{type}\" successfully",+ %{conn: conn, user: user} do+ site = new_site()+ add_guest(site, user: user, role: unquote(role))++ segment =+ insert(:segment,+ site: site,+ name: "any",+ type: unquote(type),+ owner: user+ )++ response =+ delete(conn, "/api/#{site.domain}/segments/#{segment.id}")+ |> json_response(200)++ assert %{+ "owner_id" => user.id,+ "id" => segment.id,+ "name" => segment.name,+ "segment_data" => segment.segment_data,+ "type" => "#{unquote(type)}",+ "inserted_at" => NaiveDateTime.to_iso8601(segment.inserted_at),+ "updated_at" => NaiveDateTime.to_iso8601(segment.updated_at)+ } == response++ verify_no_segment_in_db(segment)+ end+ end+ end++ defp verify_segment_in_db(segment) do+ uncomparable_keys = [:__meta__, :site]++ assert Map.drop(Repo.get(Plausible.Segment, segment.id), uncomparable_keys) ==+ Map.drop(segment, uncomparable_keys)+ end++ defp verify_no_segment_in_db(segment) do+ assert Repo.get(Plausible.Segment, segment.id) == nil+ end+enddiff --git a/test/plausible_web/plugs/feature_flag_check_plug_test.exs b/test/plausible_web/plugs/feature_flag_check_plug_test.exsnew file mode 100644index 0000000000..97aaaf6bbe--- /dev/null+++ b/test/plausible_web/plugs/feature_flag_check_plug_test.exs@@ -0,0 +1,46 @@+defmodule PlausibleWeb.Plugs.FeatureFlagCheckPlugTest do+ use PlausibleWeb.ConnCase, async: true+ use Plausible.Teams.Test+ alias PlausibleWeb.Plugs.{AuthorizeSiteAccess, FeatureFlagCheckPlug}++ setup [:create_user, :log_in, :create_site]++ test "returns 404 when any of the expected feature flags is not enabled", %{+ conn: conn,+ site: site+ } do+ # currently enabled flags are defined test/test_helper.exs+ required_flags =+ FeatureFlagCheckPlug.init([:missing_feature_flag, :channels, :saved_segments])++ conn =+ conn+ |> get_conn_with_current_user_and_site(site)+ |> FeatureFlagCheckPlug.call(required_flags)++ assert conn.halted+ assert %{"error" => "Not found"} == json_response(conn, 404)+ end++ test "passes conn when required flags are enabled", %{+ conn: conn,+ site: site+ } do+ # currently enabled flags are defined test/test_helper.exs+ required_flags = FeatureFlagCheckPlug.init([:channels, :saved_segments])++ conn =+ conn+ |> get_conn_with_current_user_and_site(site)+ |> FeatureFlagCheckPlug.call(required_flags)++ assert !conn.halted+ end++ defp get_conn_with_current_user_and_site(%Plug.Conn{} = conn, %Plausible.Site{} = site) do+ conn+ |> bypass_through(PlausibleWeb.Router)+ |> get("/plug-tests/api-basic?site=#{site.domain}")+ |> AuthorizeSiteAccess.call(AuthorizeSiteAccess.init({:all_roles, "site"}))+ end+enddiff --git a/test/support/factory.ex b/test/support/factory.exindex 30165d7075..b74ef79295 100644--- a/test/support/factory.ex+++ b/test/support/factory.ex@@ -378,6 +378,12 @@ defmodule Plausible.Factory do}end+ def segment_factory do+ %Plausible.Segment{+ segment_data: %{"filters" => [["is", "visit:entry_page", ["/blog"]]]}+ }+ end+defp hash_key() doKeyword.fetch!(Application.get_env(:plausible, PlausibleWeb.Endpoint),diff --git a/test/test_helper.exs b/test/test_helper.exsindex fef0ce84c6..f2114ce256 100644--- a/test/test_helper.exs+++ b/test/test_helper.exs@@ -9,6 +9,7 @@ Application.ensure_all_started(:double)FunWithFlags.enable(:channels)FunWithFlags.enable(:scroll_depth)FunWithFlags.enable(:teams)+FunWithFlags.enable(:saved_segments)Ecto.Adapters.SQL.Sandbox.mode(Plausible.Repo, :manual)