diff --git a/lib/plausible/goal/schema.ex b/lib/plausible/goal/schema.ex index d4dee4a6c..7ab88dbcc 100644 --- a/lib/plausible/goal/schema.ex +++ b/lib/plausible/goal/schema.ex @@ -117,9 +117,13 @@ defimpl String.Chars, for: Plausible.Goal do "Visit " <> page_path end - def to_string(%{event_name: name}) when is_binary(name) do + def to_string(%{event_name: name, currency: nil}) when is_binary(name) do name end + + def to_string(%{event_name: name, currency: currency}) when is_binary(name) do + name <> " (#{currency})" + end end defimpl Phoenix.HTML.Safe, for: Plausible.Goal do diff --git a/lib/plausible/goals.ex b/lib/plausible/goals.ex index 1d5cfebcc..fc8fb9d3d 100644 --- a/lib/plausible/goals.ex +++ b/lib/plausible/goals.ex @@ -11,69 +11,76 @@ defmodule Plausible.Goals do If the created goal is a revenue goal, it sets site.updated_at to be refreshed by the sites cache, as revenue goals are used during ingestion. """ - def create(site, params, now \\ DateTime.utc_now()) do - params = Map.merge(params, %{"site_id" => site.id}) - - Ecto.Multi.new() - |> Ecto.Multi.insert(:goal, Goal.changeset(%Goal{}, params)) - |> Ecto.Multi.run(:site, fn repo, %{goal: goal} -> - if Goal.revenue?(goal) do - now = - now - |> DateTime.truncate(:second) - |> DateTime.to_naive() - - site - |> Ecto.Changeset.change(updated_at: now) - |> repo.update() - else - {:ok, site} + def create(site, params, opts \\ []) do + now = Keyword.get(opts, :now, DateTime.utc_now()) + upsert? = Keyword.get(opts, :upsert?, false) + + Repo.transaction(fn -> + case insert_goal(site, params, upsert?) do + {:ok, :insert, goal} -> + # credo:disable-for-next-line Credo.Check.Refactor.Nesting + if Goal.revenue?(goal) do + Plausible.Site.Cache.touch_site!(site, now) + end + + Repo.preload(goal, :site) + + {:ok, :upsert, goal} -> + Repo.preload(goal, :site) + + {:error, changeset} -> + Repo.rollback(changeset) end end) - |> Repo.transaction() - |> case do - {:ok, %{goal: goal}} -> {:ok, Repo.preload(goal, :site)} - {:error, _failed_operation, failed_value, _changes_so_far} -> {:error, failed_value} - end end - def find_or_create(site, %{"goal_type" => "event", "event_name" => event_name}) do - query = - from g in Goal, - inner_join: assoc(g, :site), - where: g.site_id == ^site.id, - where: g.event_name == ^event_name, - preload: [:site] - - goal = Repo.one(query) + def find_or_create(site, %{ + "goal_type" => "event", + "event_name" => event_name, + "currency" => currency + }) + when is_binary(event_name) and is_binary(currency) do + params = %{"event_name" => event_name, "currency" => currency} + + with {:ok, goal} <- create(site, params, upsert?: true) do + if to_string(goal.currency) == currency do + {:ok, goal} + else + # we must disallow creation of the same goal name with different currency + changeset = + goal + |> Goal.changeset() + |> Ecto.Changeset.add_error( + :event_name, + "'#{goal.event_name}' (with currency: #{goal.currency}) has already been taken" + ) - case goal do - nil -> create(site, %{"event_name" => event_name}) - goal -> {:ok, goal} + {:error, changeset} + end end end + def find_or_create(site, %{"goal_type" => "event", "event_name" => event_name}) + when is_binary(event_name) do + create(site, %{"event_name" => event_name}, upsert?: true) + end + def find_or_create(_, %{"goal_type" => "event"}), do: {:missing, "event_name"} def find_or_create(site, %{"goal_type" => "page", "page_path" => page_path}) do - query = - from g in Goal, - inner_join: assoc(g, :site), - where: g.site_id == ^site.id, - where: g.page_path == ^page_path, - preload: [:site] - - goal = Repo.one(query) - - case goal do - nil -> create(site, %{"page_path" => page_path}) - goal -> {:ok, goal} - end + create(site, %{"page_path" => page_path}, upsert?: true) end def find_or_create(_, %{"goal_type" => "page"}), do: {:missing, "page_path"} def for_site(site, opts \\ []) do + site + |> for_site_query(opts) + |> Repo.all() + |> Enum.map(&maybe_trim/1) + end + + def for_site_query(site, opts \\ []) do query = from g in Goal, inner_join: assoc(g, :site), @@ -81,30 +88,15 @@ defmodule Plausible.Goals do order_by: [desc: g.id], preload: [:site] - query = - if opts[:preload_funnels?] do - from g in query, - left_join: assoc(g, :funnels), - group_by: g.id, - preload: [:funnels] - else - query - end - - query = - if opts[:preload_funnels?] do - from(g in query, - left_join: assoc(g, :funnels), - group_by: g.id, - preload: [:funnels] - ) - else - query - end - - query - |> Repo.all() - |> Enum.map(&maybe_trim/1) + if opts[:preload_funnels?] do + from(g in query, + left_join: assoc(g, :funnels), + group_by: g.id, + preload: [:funnels] + ) + else + query + end end @doc """ @@ -188,6 +180,35 @@ defmodule Plausible.Goals do ) end + defp insert_goal(site, params, upsert?) do + params = Map.delete(params, "site_id") + + insert_opts = + if upsert? do + [on_conflict: :nothing] + else + [] + end + + changeset = Goal.changeset(%Goal{site_id: site.id}, params) + + with {:ok, goal} <- Repo.insert(changeset, insert_opts) do + # Upsert with `on_conflict: :nothing` strategy + # will result in goal struct missing primary key field + # which is generated by the database. + if goal.id do + {:ok, :insert, goal} + else + get_params = + goal + |> Map.take([:site_id, :event_name, :page_path]) + |> Enum.reject(fn {_, value} -> is_nil(value) end) + + {:ok, :upsert, Repo.get_by!(Goal, get_params)} + end + end + end + defp maybe_trim(%Goal{} = goal) do # we make sure that even if we saved goals erroneously with trailing # space, it's removed during fetch diff --git a/lib/plausible/plugins/api/goals.ex b/lib/plausible/plugins/api/goals.ex new file mode 100644 index 000000000..93372c2c3 --- /dev/null +++ b/lib/plausible/plugins/api/goals.ex @@ -0,0 +1,77 @@ +defmodule Plausible.Plugins.API.Goals do + @moduledoc """ + Plugins API context module for Goals. + All high level Goal operations should be implemented here. + """ + + import Ecto.Query + import Plausible.Plugins.API.Pagination + + alias Plausible.Repo + alias PlausibleWeb.Plugins.API.Schemas.Goal.CreateRequest + + @type create_request() :: + CreateRequest.CustomEvent.t() + | CreateRequest.Revenue.t() + | CreateRequest.Pageview.t() + + @spec create( + Plausible.Site.t(), + create_request() | list(create_request()) + ) :: {:ok, list(Plausible.Goal.t())} | {:error, Ecto.Changeset.t()} + def create(site, goal_or_goals) do + Repo.transaction(fn -> find_or_create(site, goal_or_goals) end) + end + + @spec get_goals(Plausible.Site.t(), map()) :: {:ok, Paginator.Page.t()} + def get_goals(site, params) do + query = Plausible.Goals.for_site_query(site, preload_funnels?: true) + + {:ok, paginate(query, params, cursor_fields: [{:id, :desc}])} + end + + @spec get(Plausible.Site.t(), pos_integer()) :: nil | Plausible.Goal.t() + def get(site, id) when is_integer(id) do + site + |> get_query() + |> where([g], g.id == ^id) + |> Repo.one() + end + + defp get_query(site) do + from g in Plausible.Goal, + where: g.site_id == ^site.id, + order_by: [desc: g.id], + left_join: assoc(g, :funnels), + group_by: g.id, + preload: [:funnels] + end + + defp convert_to_create_params(%CreateRequest.CustomEvent{goal: %{event_name: event_name}}) do + %{"goal_type" => "event", "event_name" => event_name} + end + + defp convert_to_create_params(%CreateRequest.Revenue{ + goal: %{event_name: event_name, currency: currency} + }) do + %{"goal_type" => "event", "event_name" => event_name, "currency" => currency} + end + + defp convert_to_create_params(%CreateRequest.Pageview{goal: %{path: page_path}}) do + %{"goal_type" => "page", "page_path" => page_path} + end + + defp find_or_create(site, goal_or_goals) do + goal_or_goals + |> List.wrap() + |> Enum.map(fn goal -> + case Plausible.Goals.find_or_create(site, convert_to_create_params(goal)) do + {:ok, goal} -> + goal + + {:error, changeset} -> + Repo.rollback(changeset) + end + end) + end +end diff --git a/lib/plausible/plugins/api/context/shared_links.ex b/lib/plausible/plugins/api/shared_links.ex similarity index 93% rename from lib/plausible/plugins/api/context/shared_links.ex rename to lib/plausible/plugins/api/shared_links.ex index 0fc1f7334..d9f33cd3b 100644 --- a/lib/plausible/plugins/api/context/shared_links.ex +++ b/lib/plausible/plugins/api/shared_links.ex @@ -1,6 +1,6 @@ -defmodule Plausible.Plugins.API.Context.SharedLinks do +defmodule Plausible.Plugins.API.SharedLinks do @moduledoc """ - Plugins API Context module for Shared Links. + Plugins API context module for Shared Links. All high level Shared Links operations should be implemented here. """ import Ecto.Query diff --git a/lib/plausible/plugins/api/tokens.ex b/lib/plausible/plugins/api/tokens.ex index 821ef3687..b5ab19a68 100644 --- a/lib/plausible/plugins/api/tokens.ex +++ b/lib/plausible/plugins/api/tokens.ex @@ -10,7 +10,7 @@ defmodule Plausible.Plugins.API.Tokens do import Ecto.Query @spec create(Site.t(), String.t()) :: - {:ok, Token.t(), String.t(), String.t()} | {:error, Ecto.Changeset.t()} + {:ok, Token.t(), String.t()} | {:error, Ecto.Changeset.t()} def create(%Site{} = site, description, generated_token \\ Token.generate()) do with changeset <- Token.insert_changeset(site, generated_token, %{description: description}), {:ok, saved_token} <- Repo.insert(changeset) do diff --git a/lib/plausible/site/cache.ex b/lib/plausible/site/cache.ex index 8c62675c6..42cd6c2d4 100644 --- a/lib/plausible/site/cache.ex +++ b/lib/plausible/site/cache.ex @@ -209,6 +209,18 @@ defmodule Plausible.Site.Cache do [:plausible, :cache, cache_name, :refresh, mode] end + @spec touch_site!(Site.t(), DateTime.t()) :: Site.t() + def touch_site!(site, now) do + now = + now + |> DateTime.truncate(:second) + |> DateTime.to_naive() + + site + |> Ecto.Changeset.change(updated_at: now) + |> Plausible.Repo.update!() + end + def enabled?() do Application.fetch_env!(:plausible, :sites_by_domain_cache_enabled) == true end diff --git a/lib/plausible_web.ex b/lib/plausible_web.ex index 4c6f9d8dc..4c2cb6b4b 100644 --- a/lib/plausible_web.ex +++ b/lib/plausible_web.ex @@ -52,7 +52,8 @@ defmodule PlausibleWeb do alias PlausibleWeb.Plugins.API.Schemas alias PlausibleWeb.Plugins.API.Views - alias Plausible.Plugins.API.Context + alias PlausibleWeb.Plugins.API.Errors + alias Plausible.Plugins.API plug(OpenApiSpex.Plug.CastAndValidate, json_render_error_v2: true, replace_params: false) diff --git a/lib/plausible_web/live/goal_settings/list.ex b/lib/plausible_web/live/goal_settings/list.ex index 00fdabee7..1dbdfb719 100644 --- a/lib/plausible_web/live/goal_settings/list.ex +++ b/lib/plausible_web/live/goal_settings/list.ex @@ -58,7 +58,7 @@ defmodule PlausibleWeb.Live.GoalSettings.List do Pageview Custom Event - Revenue Goal: <%= goal.currency %> + Revenue Goal - belongs to funnel(s) diff --git a/lib/plausible_web/plugins/api/controllers/goals.ex b/lib/plausible_web/plugins/api/controllers/goals.ex new file mode 100644 index 000000000..7e9b2738c --- /dev/null +++ b/lib/plausible_web/plugins/api/controllers/goals.ex @@ -0,0 +1,160 @@ +defmodule PlausibleWeb.Plugins.API.Controllers.Goals do + @moduledoc """ + Controller for the Goal resource under Plugins API + """ + use PlausibleWeb, :plugins_api_controller + + operation(:index, + summary: "Retrieve Goals", + parameters: [ + limit: [in: :query, type: :integer, description: "Maximum entries per page", example: 10], + after: [ + in: :query, + type: :string, + description: "Cursor value to seek after - generated internally" + ], + before: [ + in: :query, + type: :string, + description: "Cursor value to seek before - generated internally" + ] + ], + responses: %{ + ok: {"Goals response", "application/json", Schemas.Goal.ListResponse}, + unauthorized: {"Unauthorized", "application/json", Schemas.Unauthorized} + } + ) + + operation(:create, + id: "Goal.GetOrCreate", + summary: "Get or create Goal", + request_body: {"Goal params", "application/json", Schemas.Goal.CreateRequest}, + responses: %{ + created: + {"Goal", "application/json", + %OpenApiSpex.Schema{ + oneOf: [Schemas.Goal.ListResponse, Schemas.Goal] + }}, + unauthorized: {"Unauthorized", "application/json", Schemas.Unauthorized}, + unprocessable_entity: + {"Unprocessable entity", "application/json", Schemas.UnprocessableEntity} + } + ) + + @spec create(Plug.Conn.t(), map()) :: Plug.Conn.t() + def create( + %{private: %{open_api_spex: %{body_params: %{goal: _} = goal}}} = conn, + _params + ) do + site = conn.assigns.authorized_site + + case API.Goals.create(site, goal) do + {:ok, [goal]} -> + conn + |> put_view(Views.Goal) + |> put_status(:created) + |> put_resp_header("location", goals_url(base_uri(), :get, goal.id)) + |> render("goal.json", goal: goal, authorized_site: site) + + {:error, changeset} -> + Errors.error(conn, 422, changeset) + end + end + + def create( + %{private: %{open_api_spex: %{body_params: %{goals: goals}}}} = conn, + _params + ) do + site = conn.assigns.authorized_site + + case API.Goals.create(site, goals) do + {:ok, goals} -> + location_headers = Enum.map(goals, &{"location", goals_url(base_uri(), :get, &1.id)}) + + conn + |> prepend_resp_headers(location_headers) + |> put_view(Views.Goal) + |> put_status(:created) + |> render("index.json", goals: goals, authorized_site: site) + + {:error, changeset} -> + Errors.error(conn, 422, changeset) + end + end + + @spec index(Plug.Conn.t(), %{}) :: Plug.Conn.t() + def index(conn, _params) do + {:ok, pagination} = API.Goals.get_goals(conn.assigns.authorized_site, conn.query_params) + + conn + |> put_view(Views.Goal) + |> render("index.json", %{pagination: pagination}) + end + + operation(:get, + summary: "Retrieve Goal by ID", + parameters: [ + id: [ + in: :path, + type: :integer, + description: "Goal ID", + example: 123, + required: true + ] + ], + responses: %{ + ok: {"Goal", "application/json", Schemas.Goal}, + not_found: {"NotFound", "application/json", Schemas.NotFound}, + unauthorized: {"Unauthorized", "application/json", Schemas.Unauthorized}, + unprocessable_entity: + {"Unprocessable entity", "application/json", Schemas.UnprocessableEntity} + } + ) + + @spec get(Plug.Conn.t(), map()) :: Plug.Conn.t() + def get(%{private: %{open_api_spex: %{params: %{id: id}}}} = conn, _params) do + site = conn.assigns.authorized_site + + case API.Goals.get(site, id) do + nil -> + conn + |> put_view(Views.Error) + |> put_status(:not_found) + |> render("404.json") + + goal -> + conn + |> put_view(Views.Goal) + |> put_status(:ok) + |> render("goal.json", goal: goal, authorized_site: site) + end + end + + operation(:delete, + summary: "Delete Goal by ID", + parameters: [ + id: [ + in: :path, + type: :integer, + description: "Goal ID", + example: 123, + required: true + ] + ], + responses: %{ + no_content: {"NoContent", nil, nil}, + unauthorized: {"Unauthorized", "application/json", Schemas.Unauthorized} + } + ) + + @spec delete(Plug.Conn.t(), map()) :: Plug.Conn.t() + def delete(%{private: %{open_api_spex: %{params: %{id: id}}}} = conn, _params) do + case Plausible.Goals.delete(id, conn.assigns.authorized_site) do + :ok -> + send_resp(conn, :no_content, "") + + {:error, :not_found} -> + send_resp(conn, :no_content, "") + end + end +end diff --git a/lib/plausible_web/plugins/api/controllers/shared_links.ex b/lib/plausible_web/plugins/api/controllers/shared_links.ex index a344b7e38..84b59d03b 100644 --- a/lib/plausible_web/plugins/api/controllers/shared_links.ex +++ b/lib/plausible_web/plugins/api/controllers/shared_links.ex @@ -28,7 +28,7 @@ defmodule PlausibleWeb.Plugins.API.Controllers.SharedLinks do @spec index(Plug.Conn.t(), %{}) :: Plug.Conn.t() def index(conn, _params) do {:ok, pagination} = - Context.SharedLinks.get_shared_links(conn.assigns.authorized_site, conn.query_params) + API.SharedLinks.get_shared_links(conn.assigns.authorized_site, conn.query_params) conn |> put_view(Views.SharedLink) @@ -36,7 +36,7 @@ defmodule PlausibleWeb.Plugins.API.Controllers.SharedLinks do end operation(:create, - summary: "Create Shared Link", + summary: "Get or create Shared Link", request_body: {"Shared Link params", "application/json", Schemas.SharedLink.CreateRequest}, responses: %{ created: {"Shared Link", "application/json", Schemas.SharedLink}, @@ -51,7 +51,9 @@ defmodule PlausibleWeb.Plugins.API.Controllers.SharedLinks do %{ private: %{ open_api_spex: %{ - body_params: %Schemas.SharedLink.CreateRequest{name: name, password: password} + body_params: %Schemas.SharedLink.CreateRequest{ + shared_link: %{name: name} = shared_link + } } } } = conn, @@ -59,7 +61,7 @@ defmodule PlausibleWeb.Plugins.API.Controllers.SharedLinks do ) do site = conn.assigns.authorized_site - {:ok, shared_link} = Context.SharedLinks.get_or_create(site, name, password) + {:ok, shared_link} = API.SharedLinks.get_or_create(site, name, shared_link[:password]) conn |> put_view(Views.SharedLink) @@ -92,7 +94,7 @@ defmodule PlausibleWeb.Plugins.API.Controllers.SharedLinks do def get(%{private: %{open_api_spex: %{params: %{id: id}}}} = conn, _params) do site = conn.assigns.authorized_site - case Context.SharedLinks.get(site, id) do + case API.SharedLinks.get(site, id) do nil -> conn |> put_view(Views.Error) diff --git a/lib/plausible_web/plugins/api/errors.ex b/lib/plausible_web/plugins/api/errors.ex index 5c3a0980a..530b29919 100644 --- a/lib/plausible_web/plugins/api/errors.ex +++ b/lib/plausible_web/plugins/api/errors.ex @@ -4,6 +4,7 @@ defmodule PlausibleWeb.Plugins.API.Errors do """ import Plug.Conn + import Plausible.ChangesetHelpers @spec unauthorized(Plug.Conn.t()) :: Plug.Conn.t() def unauthorized(conn) do @@ -12,15 +13,36 @@ defmodule PlausibleWeb.Plugins.API.Errors do |> error(:unauthorized, "Plugins API: unauthorized") end - @spec error(Plug.Conn.t(), Plug.Conn.status(), String.t() | [String.t()]) :: Plug.Conn.t() + @spec error( + Plug.Conn.t(), + Plug.Conn.status(), + String.t() | [String.t()] | Ecto.Changeset.t() | [Ecto.Changeset.t()] + ) :: + Plug.Conn.t() def error(conn, status, message) when is_binary(message) do error(conn, status, [message]) end + def error(conn, status, message) when is_map(message) do + error(conn, status, [message]) + end + def error(conn, status, messages) when is_list(messages) do response = Jason.encode!(%{ - errors: Enum.map(messages, &%{detail: &1}) + errors: + Enum.map(messages, fn + message when is_binary(message) -> + %{detail: message} + + %Ecto.Changeset{} = changeset -> + changeset + |> traverse_errors() + |> Enum.map(fn {key, message} -> + %{detail: "#{key}: #{message}"} + end) + end) + |> List.flatten() }) conn diff --git a/lib/plausible_web/plugins/api/router.ex b/lib/plausible_web/plugins/api/router.ex index 2ab4fdc0f..88abc4a2d 100644 --- a/lib/plausible_web/plugins/api/router.ex +++ b/lib/plausible_web/plugins/api/router.ex @@ -21,6 +21,11 @@ defmodule PlausibleWeb.Plugins.API.Router do get("/shared_links", SharedLinks, :index) get("/shared_links/:id", SharedLinks, :get) - post("/shared_links", SharedLinks, :create) + put("/shared_links", SharedLinks, :create) + + get("/goals", Goals, :index) + get("/goals/:id", Goals, :get) + put("/goals", Goals, :create) + delete("/goals/:id", Goals, :delete) end end diff --git a/lib/plausible_web/plugins/api/schemas/goal.ex b/lib/plausible_web/plugins/api/schemas/goal.ex new file mode 100644 index 000000000..060c72efe --- /dev/null +++ b/lib/plausible_web/plugins/api/schemas/goal.ex @@ -0,0 +1,32 @@ +defmodule PlausibleWeb.Plugins.API.Schemas.Goal do + @moduledoc """ + OpenAPI schema for Goal + """ + use PlausibleWeb, :open_api_schema + + OpenApiSpex.schema(%{ + title: "Goal", + description: "Goal object", + type: :object, + discriminator: %OpenApiSpex.Discriminator{ + propertyName: "goal_type", + mapping: %{ + "Goal.CustomEvent" => Schemas.Goal.CustomEvent, + "Goal.Pageview" => Schemas.Goal.Pageview, + "Goal.Revenue" => Schemas.Goal.Revenue + } + }, + oneOf: [ + Schemas.Goal.CustomEvent, + Schemas.Goal.Revenue, + Schemas.Goal.Pageview + ], + example: %{ + goal_type: "Goal.Revenue", + goal: %{ + currency: "EUR", + event_name: "Purchase" + } + } + }) +end diff --git a/lib/plausible_web/plugins/api/schemas/goal/create_request.ex b/lib/plausible_web/plugins/api/schemas/goal/create_request.ex new file mode 100644 index 000000000..b3ca00925 --- /dev/null +++ b/lib/plausible_web/plugins/api/schemas/goal/create_request.ex @@ -0,0 +1,38 @@ +defmodule PlausibleWeb.Plugins.API.Schemas.Goal.CreateRequest do + @moduledoc """ + OpenAPI schema for Goal creation request + """ + use Plausible.Funnel + use PlausibleWeb, :open_api_schema + + OpenApiSpex.schema(%{ + title: "Goal.CreateRequest", + description: "Goal creation params", + type: :object, + oneOf: [ + %Schema{ + title: "Goal.CreateRequest.BulkGetOrCreate", + type: :object, + description: "Bulk goal creation request", + required: [:goals], + properties: %{ + goals: %Schema{ + type: :array, + minItems: 1, + maxItems: Funnel.max_steps(), + items: %Schema{ + oneOf: [ + Schemas.Goal.CreateRequest.CustomEvent, + Schemas.Goal.CreateRequest.Revenue, + Schemas.Goal.CreateRequest.Pageview + ] + } + } + } + }, + Schemas.Goal.CreateRequest.CustomEvent, + Schemas.Goal.CreateRequest.Revenue, + Schemas.Goal.CreateRequest.Pageview + ] + }) +end diff --git a/lib/plausible_web/plugins/api/schemas/goal/create_request/custom_event.ex b/lib/plausible_web/plugins/api/schemas/goal/create_request/custom_event.ex new file mode 100644 index 000000000..758a428cd --- /dev/null +++ b/lib/plausible_web/plugins/api/schemas/goal/create_request/custom_event.ex @@ -0,0 +1,34 @@ +defmodule PlausibleWeb.Plugins.API.Schemas.Goal.CreateRequest.CustomEvent do + @moduledoc """ + OpenAPI schema for Custom Event Goal creation request + """ + + use PlausibleWeb, :open_api_schema + + OpenApiSpex.schema(%{ + title: "Goal.CreateRequest.CustomEvent", + description: "Custom Event Goal creation params", + type: :object, + required: [:goal, :goal_type], + properties: %{ + goal_type: %Schema{ + type: :string, + enum: ["Goal.CustomEvent"], + default: "Goal.CustomEvent" + }, + goal: %Schema{ + type: :object, + required: [:event_name], + properties: %{ + event_name: %Schema{type: :string} + } + } + }, + example: %{ + goal_type: "Goal.CustomEvent", + goal: %{ + event_name: "Signup" + } + } + }) +end diff --git a/lib/plausible_web/plugins/api/schemas/goal/create_request/pageview.ex b/lib/plausible_web/plugins/api/schemas/goal/create_request/pageview.ex new file mode 100644 index 000000000..2b224dcc9 --- /dev/null +++ b/lib/plausible_web/plugins/api/schemas/goal/create_request/pageview.ex @@ -0,0 +1,34 @@ +defmodule PlausibleWeb.Plugins.API.Schemas.Goal.CreateRequest.Pageview do + @moduledoc """ + OpenAPI schema for Pageview Goal creation request + """ + + use PlausibleWeb, :open_api_schema + + OpenApiSpex.schema(%{ + title: "Goal.CreateRequest.Pageview", + description: "Pageview Goal creation params", + type: :object, + required: [:goal, :goal_type], + properties: %{ + goal_type: %Schema{ + type: :string, + enum: ["Goal.Pageview"], + default: "Goal.Pageview" + }, + goal: %Schema{ + type: :object, + required: [:path], + properties: %{ + path: %Schema{type: :string} + } + } + }, + example: %{ + goal_type: "Goal.Pageview", + goal: %{ + path: "/checkout" + } + } + }) +end diff --git a/lib/plausible_web/plugins/api/schemas/goal/create_request/revenue.ex b/lib/plausible_web/plugins/api/schemas/goal/create_request/revenue.ex new file mode 100644 index 000000000..4b8f41376 --- /dev/null +++ b/lib/plausible_web/plugins/api/schemas/goal/create_request/revenue.ex @@ -0,0 +1,36 @@ +defmodule PlausibleWeb.Plugins.API.Schemas.Goal.CreateRequest.Revenue do + @moduledoc """ + OpenAPI schema for Custom Event Goal creation request + """ + + use PlausibleWeb, :open_api_schema + + OpenApiSpex.schema(%{ + title: "Goal.CreateRequest.Revenue", + description: "Revenue Goal creation params", + type: :object, + required: [:goal, :goal_type], + properties: %{ + goal_type: %Schema{ + type: :string, + enum: ["Goal.Revenue"], + default: "Goal.Revenue" + }, + goal: %Schema{ + type: :object, + required: [:event_name, :currency], + properties: %{ + event_name: %Schema{type: :string}, + currency: %Schema{type: :string} + } + } + }, + example: %{ + goal_type: "Goal.Revenue", + goal: %{ + event_name: "Purchase", + currency: "EUR" + } + } + }) +end diff --git a/lib/plausible_web/plugins/api/schemas/goal/custom_event.ex b/lib/plausible_web/plugins/api/schemas/goal/custom_event.ex new file mode 100644 index 000000000..fac4d810c --- /dev/null +++ b/lib/plausible_web/plugins/api/schemas/goal/custom_event.ex @@ -0,0 +1,30 @@ +defmodule PlausibleWeb.Plugins.API.Schemas.Goal.CustomEvent do + @moduledoc """ + OpenAPI schema for Custom Event Goal object + """ + use PlausibleWeb, :open_api_schema + + OpenApiSpex.schema(%{ + description: "Custom Event Goal object", + title: "Goal.CustomEvent", + type: :object, + allOf: [ + Schemas.Goal.Type, + %Schema{ + type: :object, + required: [:goal], + properties: %{ + goal: %Schema{ + type: :object, + required: [:id, :display_name, :event_name], + properties: %{ + id: %Schema{type: :integer, description: "Goal ID", readOnly: true}, + display_name: %Schema{type: :string, description: "Display name", readOnly: true}, + event_name: %Schema{type: :string, description: "Event Name"} + } + } + } + } + ] + }) +end diff --git a/lib/plausible_web/plugins/api/schemas/goal/list_response.ex b/lib/plausible_web/plugins/api/schemas/goal/list_response.ex new file mode 100644 index 000000000..b458d64d3 --- /dev/null +++ b/lib/plausible_web/plugins/api/schemas/goal/list_response.ex @@ -0,0 +1,29 @@ +defmodule PlausibleWeb.Plugins.API.Schemas.Goal.ListResponse do + @moduledoc """ + OpenAPI schema for Goals list response + """ + use PlausibleWeb, :open_api_schema + + OpenApiSpex.schema(%{ + title: "Goal.ListResponse", + description: "Goals list response", + type: :object, + required: [:goals, :meta], + properties: %{ + goals: %Schema{ + items: Schemas.Goal, + type: :array + }, + meta: %OpenApiSpex.Schema{ + required: [:pagination], + properties: %{ + pagination: %OpenApiSpex.Reference{ + "$ref": "#/components/schemas/PaginationMetadata" + } + }, + type: :object, + items: Schemas.PaginationMetadata + } + } + }) +end diff --git a/lib/plausible_web/plugins/api/schemas/goal/pageview.ex b/lib/plausible_web/plugins/api/schemas/goal/pageview.ex new file mode 100644 index 000000000..d68a0a47e --- /dev/null +++ b/lib/plausible_web/plugins/api/schemas/goal/pageview.ex @@ -0,0 +1,30 @@ +defmodule PlausibleWeb.Plugins.API.Schemas.Goal.Pageview do + @moduledoc """ + OpenAPI schema for Pageview Goal object + """ + use PlausibleWeb, :open_api_schema + + OpenApiSpex.schema(%{ + description: "Pageview Goal object", + title: "Goal.Pageview", + type: :object, + allOf: [ + Schemas.Goal.Type, + %Schema{ + type: :object, + required: [:goal], + properties: %{ + goal: %Schema{ + type: :object, + required: [:id, :display_name, :path], + properties: %{ + id: %Schema{type: :integer, description: "Goal ID", readOnly: true}, + display_name: %Schema{type: :string, description: "Display name", readOnly: true}, + path: %Schema{type: :string, description: "Page Path"} + } + } + } + } + ] + }) +end diff --git a/lib/plausible_web/plugins/api/schemas/goal/revenue.ex b/lib/plausible_web/plugins/api/schemas/goal/revenue.ex new file mode 100644 index 000000000..c25406489 --- /dev/null +++ b/lib/plausible_web/plugins/api/schemas/goal/revenue.ex @@ -0,0 +1,31 @@ +defmodule PlausibleWeb.Plugins.API.Schemas.Goal.Revenue do + @moduledoc """ + OpenAPI schema for Revenue Goal object + """ + use PlausibleWeb, :open_api_schema + + OpenApiSpex.schema(%{ + description: "Revenue Goal object", + title: "Goal.Revenue", + type: :object, + allOf: [ + Schemas.Goal.Type, + %Schema{ + type: :object, + required: [:goal], + properties: %{ + goal: %Schema{ + type: :object, + required: [:id, :display_name, :event_name, :currency], + properties: %{ + id: %Schema{type: :integer, description: "Goal ID", readOnly: true}, + display_name: %Schema{type: :string, description: "Display name", readOnly: true}, + event_name: %Schema{type: :string, description: "Event Name"}, + currency: %Schema{type: :string, description: "Currency"} + } + } + } + } + ] + }) +end diff --git a/lib/plausible_web/plugins/api/schemas/goal/type.ex b/lib/plausible_web/plugins/api/schemas/goal/type.ex new file mode 100644 index 000000000..ebc41b0e9 --- /dev/null +++ b/lib/plausible_web/plugins/api/schemas/goal/type.ex @@ -0,0 +1,18 @@ +defmodule PlausibleWeb.Plugins.API.Schemas.Goal.Type do + @moduledoc """ + OpenAPI schema for common Goal Type + + Future-proof: funnels etc. + """ + use PlausibleWeb, :open_api_schema + + OpenApiSpex.schema(%{ + title: "Goal.Type", + description: "Properties common to all Goals", + type: :object, + properties: %{ + goal_type: %Schema{type: :string} + }, + required: [:goal_type] + }) +end diff --git a/lib/plausible_web/plugins/api/schemas/shared_link.ex b/lib/plausible_web/plugins/api/schemas/shared_link.ex index 81ecff96f..a7dec0940 100644 --- a/lib/plausible_web/plugins/api/schemas/shared_link.ex +++ b/lib/plausible_web/plugins/api/schemas/shared_link.ex @@ -7,9 +7,9 @@ defmodule PlausibleWeb.Plugins.API.Schemas.SharedLink do OpenApiSpex.schema(%{ description: "Shared Link object", type: :object, - required: [:data], + required: [:shared_link], properties: %{ - data: %Schema{ + shared_link: %Schema{ type: :object, required: [:id, :name, :password_protected, :href], properties: %{ @@ -22,6 +22,14 @@ defmodule PlausibleWeb.Plugins.API.Schemas.SharedLink do href: %Schema{type: :string, description: "Shared Link URL"} } } + }, + example: %{ + shared_link: %{ + id: 1024, + name: "Public Dashboard", + password_protected: false, + href: "https://example.com" + } } }) end diff --git a/lib/plausible_web/plugins/api/schemas/shared_link/create_request.ex b/lib/plausible_web/plugins/api/schemas/shared_link/create_request.ex index 65e5754e1..0b6b3726f 100644 --- a/lib/plausible_web/plugins/api/schemas/shared_link/create_request.ex +++ b/lib/plausible_web/plugins/api/schemas/shared_link/create_request.ex @@ -8,13 +8,19 @@ defmodule PlausibleWeb.Plugins.API.Schemas.SharedLink.CreateRequest do title: "SharedLink.CreateRequest", description: "Shared Links creation params", type: :object, - required: [:name], + required: [:shared_link], properties: %{ - name: %Schema{description: "Shared Link Name", type: :string}, - password: %Schema{description: "Shared Link Password", type: :string} + shared_link: %Schema{ + type: :object, + required: [:name], + properties: %{ + name: %Schema{description: "Shared Link Name", type: :string}, + password: %Schema{description: "Shared Link Password", type: :string} + } + } }, example: %{ - name: "My Shared Dashboard" + shared_link: %{name: "My Shared Dashboard"} } }) end diff --git a/lib/plausible_web/plugins/api/schemas/shared_link/list_response.ex b/lib/plausible_web/plugins/api/schemas/shared_link/list_response.ex index 66ebc70bb..87464c463 100644 --- a/lib/plausible_web/plugins/api/schemas/shared_link/list_response.ex +++ b/lib/plausible_web/plugins/api/schemas/shared_link/list_response.ex @@ -8,9 +8,9 @@ defmodule PlausibleWeb.Plugins.API.Schemas.SharedLink.ListResponse do title: "SharedLink.ListResponse", description: "Shared Links list response", type: :object, - required: [:data, :meta], + required: [:shared_links, :meta], properties: %{ - data: %Schema{ + shared_links: %Schema{ items: Schemas.SharedLink, type: :array }, diff --git a/lib/plausible_web/plugins/api/views/goal.ex b/lib/plausible_web/plugins/api/views/goal.ex new file mode 100644 index 000000000..ab7b32254 --- /dev/null +++ b/lib/plausible_web/plugins/api/views/goal.ex @@ -0,0 +1,70 @@ +defmodule PlausibleWeb.Plugins.API.Views.Goal do + @moduledoc """ + View for rendering Goals in the Plugins API + """ + + use PlausibleWeb, :plugins_api_view + + def render("index.json", %{ + pagination: %{entries: goals, metadata: metadata}, + authorized_site: site, + conn: conn + }) do + %{ + goals: render_many(goals, __MODULE__, "goal.json", authorized_site: site), + meta: render_metadata_links(metadata, :goals_url, :index, conn.query_params) + } + end + + def render("index.json", %{ + goals: goals, + authorized_site: site, + conn: conn + }) do + %{ + goals: render_many(goals, __MODULE__, "goal.json", authorized_site: site), + meta: render_metadata_links(%{}, :goals_url, :index, conn.query_params) + } + end + + def render("goal.json", %{ + goal: %{event_name: nil} = pageview + }) do + %{ + goal_type: "Goal.Pageview", + goal: %{ + id: pageview.id, + display_name: to_string(pageview), + path: pageview.page_path + } + } + end + + def render("goal.json", %{ + goal: %{page_path: nil, currency: nil} = custom_event + }) do + %{ + goal_type: "Goal.CustomEvent", + goal: %{ + id: custom_event.id, + display_name: to_string(custom_event), + event_name: custom_event.event_name + } + } + end + + def render("goal.json", %{ + goal: %{page_path: nil, currency: currency} = revenue_goal + }) + when is_atom(currency) do + %{ + goal_type: "Goal.Revenue", + goal: %{ + id: revenue_goal.id, + display_name: to_string(revenue_goal), + event_name: revenue_goal.event_name, + currency: revenue_goal.currency + } + } + end +end diff --git a/lib/plausible_web/plugins/api/views/shared_link.ex b/lib/plausible_web/plugins/api/views/shared_link.ex index e3b5ed2a3..bd5a71ebd 100644 --- a/lib/plausible_web/plugins/api/views/shared_link.ex +++ b/lib/plausible_web/plugins/api/views/shared_link.ex @@ -11,7 +11,8 @@ defmodule PlausibleWeb.Plugins.API.Views.SharedLink do conn: conn }) do %{ - data: render_many(shared_links, __MODULE__, "shared_link.json", authorized_site: site), + shared_links: + render_many(shared_links, __MODULE__, "shared_link.json", authorized_site: site), meta: render_metadata_links(metadata, :shared_links_url, :index, conn.query_params) } end @@ -21,7 +22,7 @@ defmodule PlausibleWeb.Plugins.API.Views.SharedLink do authorized_site: site }) do %{ - data: %{ + shared_link: %{ id: shared_link.id, name: shared_link.name, password_protected: is_binary(shared_link.password_hash), diff --git a/test/plausible/goals_test.exs b/test/plausible/goals_test.exs index 6fdba92d3..98c7ab4f0 100644 --- a/test/plausible/goals_test.exs +++ b/test/plausible/goals_test.exs @@ -38,6 +38,16 @@ defmodule Plausible.GoalsTest do assert {"has already been taken", _} = changeset.errors[:event_name] end + test "create/2 fails to create the same currency goal twice" do + site = insert(:site) + {:ok, _} = Goals.create(site, %{"event_name" => "foo bar", "currency" => "EUR"}) + + assert {:error, changeset} = + Goals.create(site, %{"event_name" => "foo bar", "currency" => "EUR"}) + + assert {"has already been taken", _} = changeset.errors[:event_name] + end + test "create/2 sets site.updated_at for revenue goal" do site_1 = insert(:site, updated_at: DateTime.add(DateTime.utc_now(), -3600)) {:ok, _goal_1} = Goals.create(site_1, %{"event_name" => "Checkout", "currency" => "BRL"}) diff --git a/test/plausible/site/cache_test.exs b/test/plausible/site/cache_test.exs index 99205b12e..4e67f2f89 100644 --- a/test/plausible/site/cache_test.exs +++ b/test/plausible/site/cache_test.exs @@ -97,7 +97,10 @@ defmodule Plausible.Site.CacheTest do # the site was added yesterday so full refresh will pick it up %{id: site_id} = site = insert(:site, domain: "site1.example.com", updated_at: yesterday) # the goal was added yesterday so full refresh will pick it up - Plausible.Goals.create(site, %{"event_name" => "Purchase", "currency" => :BRL}, yesterday) + Plausible.Goals.create(site, %{"event_name" => "Purchase", "currency" => :BRL}, + now: yesterday + ) + # this goal is added "just now" Plausible.Goals.create(site, %{"event_name" => "Add to Cart", "currency" => :USD}) # and this one does not matter @@ -110,7 +113,7 @@ defmodule Plausible.Site.CacheTest do Plausible.Goals.create( site, %{"event_name" => "Purchase2", "currency" => :BRL}, - DateTime.add(DateTime.utc_now(), -70) + now: DateTime.add(DateTime.utc_now(), -70) ) :ok = Cache.refresh_updated_recently(cache_name: test) diff --git a/test/plausible_web/live/goal_settings/form_test.exs b/test/plausible_web/live/goal_settings/form_test.exs index 9a6d7c801..17bf7a909 100644 --- a/test/plausible_web/live/goal_settings/form_test.exs +++ b/test/plausible_web/live/goal_settings/form_test.exs @@ -75,8 +75,8 @@ defmodule PlausibleWeb.Live.GoalSettings.FormTest do refute render(parent) =~ "Foo" lv |> element("form") |> render_submit(%{goal: %{event_name: "Foo", currency: "EUR"}}) parent_html = render(parent) - assert parent_html =~ "Foo" - assert parent_html =~ "Revenue Goal: EUR" + assert parent_html =~ "Foo (EUR)" + assert parent_html =~ "Revenue Goal" end test "creates a pageview goal", %{conn: conn, site: site} do diff --git a/test/plausible_web/live/goal_settings_test.exs b/test/plausible_web/live/goal_settings_test.exs index d301aec1c..a0d613498 100644 --- a/test/plausible_web/live/goal_settings_test.exs +++ b/test/plausible_web/live/goal_settings_test.exs @@ -21,7 +21,7 @@ defmodule PlausibleWeb.Live.GoalSettingsTest do assert resp =~ to_string(g2) assert resp =~ "Custom Event" assert resp =~ to_string(g3) - assert resp =~ "Revenue Goal: EUR" + assert resp =~ "Revenue Goal" end test "lists goals with delete actions", %{conn: conn, site: site} do diff --git a/test/plausible_web/plugins/api/controllers/goals_test.exs b/test/plausible_web/plugins/api/controllers/goals_test.exs new file mode 100644 index 000000000..a63edd8f3 --- /dev/null +++ b/test/plausible_web/plugins/api/controllers/goals_test.exs @@ -0,0 +1,546 @@ +defmodule PlausibleWeb.Plugins.API.Controllers.GoalsTest do + use PlausibleWeb.PluginsAPICase, async: true + alias PlausibleWeb.Plugins.API.Schemas + + describe "examples" do + test "Goal.CreateRequest.Revenue" do + assert_schema( + Schemas.Goal.CreateRequest.Revenue.schema().example, + "Goal.CreateRequest.Revenue", + spec() + ) + end + + test "Goal.CreateRequest.Pageview" do + assert_schema( + Schemas.Goal.CreateRequest.Pageview.schema().example, + "Goal.CreateRequest.Pageview", + spec() + ) + end + + test "Goal.CreateRequest.CustomEvent" do + assert_schema( + Schemas.Goal.CreateRequest.CustomEvent.schema().example, + "Goal.CreateRequest.CustomEvent", + spec() + ) + end + end + + describe "unauthorized calls" do + for {method, url} <- [ + {:get, Routes.goals_url(base_uri(), :index)}, + {:get, Routes.goals_url(base_uri(), :get, 1)}, + {:put, Routes.goals_url(base_uri(), :create, %{})}, + {:delete, Routes.goals_url(base_uri(), :delete, 1)} + ] do + test "unauthorized call: #{method} #{url}", %{conn: conn} do + conn + |> unquote(method)(unquote(url)) + |> json_response(401) + |> assert_schema("UnauthorizedError", spec()) + end + end + end + + describe "put /goals - create a single goal" do + test "validates input according to the schema", %{conn: conn, token: token, site: site} do + url = Routes.goals_url(base_uri(), :create) + + conn + |> authenticate(site.domain, token) + |> put_req_header("content-type", "application/json") + |> put(url, %{goal_type: "Goal.SomeTypo", goal: %{event_name: "Signup"}}) + |> json_response(422) + |> assert_schema("UnprocessableEntityError", spec()) + end + + test "creates a custom event goal", %{conn: conn, token: token, site: site} do + url = Routes.goals_url(base_uri(), :create) + + payload = %{goal_type: "Goal.CustomEvent", goal: %{event_name: "Signup"}} + + assert_request_schema(payload, "Goal.CreateRequest.CustomEvent", spec()) + + conn = + conn + |> authenticate(site.domain, token) + |> put_req_header("content-type", "application/json") + |> put(url, payload) + + resp = + conn + |> json_response(201) + |> assert_schema("Goal", spec()) + |> assert_schema("Goal.CustomEvent", spec()) + + [location] = get_resp_header(conn, "location") + + assert location == + Routes.goals_url(base_uri(), :get, resp.goal.id) + + assert [%{event_name: "Signup"}] = Plausible.Goals.for_site(site) + end + + test "creates a revenue goal", %{conn: conn, token: token, site: site} do + url = Routes.goals_url(base_uri(), :create) + + payload = %{ + goal_type: "Goal.Revenue", + goal: %{event_name: "Purchase", currency: "EUR"} + } + + assert_request_schema(payload, "Goal.CreateRequest.Revenue", spec()) + + conn = + conn + |> authenticate(site.domain, token) + |> put_req_header("content-type", "application/json") + |> put(url, payload) + + resp = + conn + |> json_response(201) + |> assert_schema("Goal", spec()) + |> assert_schema("Goal.Revenue", spec()) + + [location] = get_resp_header(conn, "location") + + assert location == + Routes.goals_url(base_uri(), :get, resp.goal.id) + + assert [%{event_name: "Purchase", currency: :EUR}] = Plausible.Goals.for_site(site) + end + + test "fails to create a revenue goal with unknown currency", %{ + conn: conn, + token: token, + site: site + } do + url = Routes.goals_url(base_uri(), :create) + + payload = %{ + goal_type: "Goal.Revenue", + goal: %{event_name: "Purchase", currency: "DFJKHJESFHYU"} + } + + assert_request_schema(payload, "Goal.CreateRequest.Revenue", spec()) + + conn = + conn + |> authenticate(site.domain, token) + |> put_req_header("content-type", "application/json") + |> put(url, payload) + + resp = + conn + |> json_response(422) + |> assert_schema("UnprocessableEntityError", spec()) + + assert [%{detail: "currency: is invalid"}] = resp.errors + end + + test "edge case - revenue goal exists under the same name and different currency", %{ + conn: conn, + token: token, + site: site + } do + url = Routes.goals_url(base_uri(), :create) + + {:ok, _} = Plausible.Goals.create(site, %{"event_name" => "Purchase", "currency" => "USD"}) + + conn = + conn + |> authenticate(site.domain, token) + |> put_req_header("content-type", "application/json") + |> put(url, %{goal_type: "Goal.Revenue", goal: %{event_name: "Purchase", currency: "EUR"}}) + + resp = + conn + |> json_response(422) + |> assert_schema("UnprocessableEntityError", spec()) + + assert [%{detail: "event_name: 'Purchase' (with currency: USD) has already been taken"}] = + resp.errors + end + + test "creates a pageview goal", %{conn: conn, token: token, site: site} do + url = Routes.goals_url(base_uri(), :create) + + payload = %{goal_type: "Goal.Pageview", goal: %{path: "/checkout"}} + assert_request_schema(payload, "Goal.CreateRequest.Pageview", spec()) + + conn = + conn + |> authenticate(site.domain, token) + |> put_req_header("content-type", "application/json") + |> put(url, payload) + + resp = + conn + |> json_response(201) + |> assert_schema("Goal", spec()) + |> assert_schema("Goal.Pageview", spec()) + + [location] = get_resp_header(conn, "location") + + assert location == + Routes.goals_url(base_uri(), :get, resp.goal.id) + + assert [%{page_path: "/checkout"}] = Plausible.Goals.for_site(site) + end + + test "is idempotent", %{conn: conn, token: token, site: site} do + url = Routes.goals_url(base_uri(), :create) + + initial_conn = + conn + |> authenticate(site.domain, token) + |> put_req_header("content-type", "application/json") + + resp1 = + initial_conn + |> put(url, %{goal_type: "Goal.Pageview", goal: %{path: "/checkout"}}) + |> json_response(201) + |> assert_schema("Goal.Pageview", spec()) + + assert initial_conn + |> put(url, %{goal_type: "Goal.Pageview", goal: %{path: "/checkout"}}) + |> json_response(201) + |> assert_schema("Goal.Pageview", spec()) == resp1 + end + end + + describe "put /goals - bulk creation" do + test "creates a goal of each type", %{conn: conn, token: token, site: site} do + url = Routes.goals_url(base_uri(), :create) + + payload = %{ + goals: [ + %{ + goal_type: "Goal.CustomEvent", + goal: %{event_name: "Signup"} + }, + %{ + goal_type: "Goal.Revenue", + goal: %{event_name: "Purchase", currency: "EUR"} + }, + %{ + goal_type: "Goal.Pageview", + goal: %{path: "/checkout"} + } + ] + } + + assert_request_schema(payload, "Goal.CreateRequest.BulkGetOrCreate", spec()) + + conn = + conn + |> authenticate(site.domain, token) + |> put_req_header("content-type", "application/json") + |> put(url, payload) + + resp = + conn + |> json_response(201) + |> assert_schema("Goal.ListResponse", spec()) + + [l1, l2, l3] = get_resp_header(conn, "location") + + assert l1 == Routes.goals_url(base_uri(), :get, Enum.at(resp.goals, 0).goal.id) + assert l2 == Routes.goals_url(base_uri(), :get, Enum.at(resp.goals, 1).goal.id) + assert l3 == Routes.goals_url(base_uri(), :get, Enum.at(resp.goals, 2).goal.id) + + assert Enum.count(resp.goals) == 3 + + assert [ + %{page_path: "/checkout"}, + %{event_name: "Purchase", currency: :EUR}, + %{event_name: "Signup"} + ] = Plausible.Goals.for_site(site) + end + + test "no more than 8 goals can be created in bulk", %{conn: conn, token: token, site: site} do + # if this test fails due to implementation change, consider what to do with the pagination meta + # object returned in the response and also revise how funnels are created based on a list of goals + # - the funnels creation endpoint will likely reuse this schema's constraints + url = Routes.goals_url(base_uri(), :create) + + payload = + Enum.map(1..9, fn i -> + %{goal_type: "Goal.CustomEvent", goal: %{event_name: "Bulk Goal ##{i}"}} + end) + + resp = + conn + |> authenticate(site.domain, token) + |> put_req_header("content-type", "application/json") + |> put(url, %{ + goals: payload + }) + |> json_response(422) + |> assert_schema("UnprocessableEntityError", spec()) + + assert %Schemas.Error{ + detail: "Array length 9 is larger than maxItems: 8" + } in resp.errors + end + + test "is idempotent", %{conn: conn, token: token, site: site} do + url = Routes.goals_url(base_uri(), :create) + + initial_conn = + conn + |> authenticate(site.domain, token) + |> put_req_header("content-type", "application/json") + + payload = [ + %{ + goal_type: "Goal.CustomEvent", + goal: %{event_name: "Signup"} + }, + %{ + goal_type: "Goal.Revenue", + goal: %{event_name: "Purchase", currency: "EUR"} + }, + %{ + goal_type: "Goal.Pageview", + goal: %{path: "/checkout"} + } + ] + + initial_conn + |> put(url, %{goals: payload}) + |> json_response(201) + |> assert_schema("Goal.ListResponse", spec()) + + initial_conn + |> put(url, %{goals: payload}) + |> json_response(201) + |> assert_schema("Goal.ListResponse", spec()) + end + + test "edge case - revenue goals exist under the same name and different currency", %{ + conn: conn, + token: token, + site: site + } do + url = Routes.goals_url(base_uri(), :create) + + initial_conn = + conn + |> authenticate(site.domain, token) + |> put_req_header("content-type", "application/json") + + payload1 = [%{goal_type: "Goal.Revenue", goal: %{event_name: "Purchase", currency: "EUR"}}] + payload2 = [%{goal_type: "Goal.Revenue", goal: %{event_name: "Purchase", currency: "USD"}}] + + initial_conn + |> put(url, %{goals: payload1}) + |> json_response(201) + |> assert_schema("Goal.ListResponse", spec()) + + resp = + initial_conn + |> put(url, %{goals: payload2}) + |> json_response(422) + |> assert_schema("UnprocessableEntityError", spec()) + + assert [%{detail: "event_name: 'Purchase' (with currency: EUR) has already been taken"}] = + resp.errors + end + end + + describe "get /goals/:id" do + test "validates input out of the box", %{conn: conn, token: token, site: site} do + url = Routes.goals_url(base_uri(), :get, "hello") + + resp = + conn + |> authenticate(site.domain, token) + |> get(url) + |> json_response(422) + |> assert_schema("UnprocessableEntityError", spec()) + + assert %{errors: [%{detail: "Invalid integer. Got: string"}]} = resp + end + + test "retrieves revenue goal by ID", %{conn: conn, site: site, token: token} do + {:ok, goal} = + Plausible.Goals.create(site, %{"event_name" => "Purchase", "currency" => "EUR"}) + + url = Routes.goals_url(base_uri(), :get, goal.id) + + resp = + conn + |> authenticate(site.domain, token) + |> get(url) + |> json_response(200) + |> assert_schema("Goal", spec()) + |> assert_schema("Goal.Revenue", spec()) + + assert resp.goal.id == goal.id + assert resp.goal_type == "Goal.Revenue" + assert resp.goal.display_name == "Purchase (EUR)" + end + + test "retrieves pageview goal by ID", %{conn: conn, site: site, token: token} do + {:ok, goal} = Plausible.Goals.create(site, %{"page_path" => "/checkout"}) + + url = Routes.goals_url(base_uri(), :get, goal.id) + + resp = + conn + |> authenticate(site.domain, token) + |> get(url) + |> json_response(200) + |> assert_schema("Goal", spec()) + |> assert_schema("Goal.Pageview", spec()) + + assert resp.goal.id == goal.id + assert resp.goal_type == "Goal.Pageview" + assert resp.goal.display_name == "Visit /checkout" + end + + test "retrieves custom event goal by ID", %{conn: conn, site: site, token: token} do + {:ok, goal} = Plausible.Goals.create(site, %{"event_name" => "Signup"}) + + url = Routes.goals_url(base_uri(), :get, goal.id) + + resp = + conn + |> authenticate(site.domain, token) + |> get(url) + |> json_response(200) + |> assert_schema("Goal", spec()) + |> assert_schema("Goal.CustomEvent", spec()) + + assert resp.goal.id == goal.id + assert resp.goal_type == "Goal.CustomEvent" + assert resp.goal.display_name == "Signup" + end + end + + describe "get /goals" do + test "returns an empty goals list if there's none", %{ + conn: conn, + token: token, + site: site + } do + url = Routes.goals_url(base_uri(), :index) + + resp = + conn + |> authenticate(site.domain, token) + |> get(url) + |> json_response(200) + |> assert_schema("Goal.ListResponse", spec()) + + assert resp.goals == [] + assert resp.meta.pagination.has_next_page == false + assert resp.meta.pagination.has_prev_page == false + assert resp.meta.pagination.links == %{} + end + + test "returns a list of goals of each possible goal type", %{ + conn: conn, + site: site, + token: token + } do + {:ok, g1} = Plausible.Goals.create(site, %{"event_name" => "Signup"}) + {:ok, g2} = Plausible.Goals.create(site, %{"event_name" => "Purchase", "currency" => "EUR"}) + {:ok, g3} = Plausible.Goals.create(site, %{"page_path" => "/checkout"}) + + url = Routes.goals_url(base_uri(), :index) + + resp = + conn + |> authenticate(site.domain, token) + |> get(url) + |> json_response(200) + |> assert_schema("Goal.ListResponse", spec()) + + assert [checkout, purchase, signup] = resp.goals + assert checkout.goal.display_name == "Visit /checkout" + assert checkout.goal.path == "/checkout" + assert checkout.goal.id == g3.id + assert checkout.goal_type == "Goal.Pageview" + + assert purchase.goal.display_name == "Purchase (EUR)" + assert purchase.goal.currency == "EUR" + assert purchase.goal.event_name == "Purchase" + assert purchase.goal.id == g2.id + assert purchase.goal_type == "Goal.Revenue" + + assert signup.goal.display_name == "Signup" + assert signup.goal.event_name == "Signup" + assert signup.goal.id == g1.id + assert signup.goal_type == "Goal.CustomEvent" + end + + test "returns a list of goals with pagination", %{conn: conn, site: site, token: token} do + for i <- 1..5 do + insert(:goal, site: site, event_name: "Goal #{i}") + end + + url = Routes.goals_url(base_uri(), :index, limit: 2) + + initial_conn = authenticate(conn, site.domain, token) + + page1 = + initial_conn + |> get(url) + |> json_response(200) + |> assert_schema("Goal.ListResponse", spec()) + + assert [%{goal: %{event_name: "Goal 5"}}, %{goal: %{event_name: "Goal 4"}}] = page1.goals + assert page1.meta.pagination.has_next_page == true + assert page1.meta.pagination.has_prev_page == false + assert page1.meta.pagination.links.next + refute page1.meta.pagination.links[:prev] + + page2 = + initial_conn + |> get(page1.meta.pagination.links.next.url) + |> json_response(200) + |> assert_schema("Goal.ListResponse", spec()) + + assert [%{goal: %{event_name: "Goal 3"}}, %{goal: %{event_name: "Goal 2"}}] = page2.goals + + assert page2.meta.pagination.has_next_page == true + assert page2.meta.pagination.has_prev_page == true + assert page2.meta.pagination.links.next + assert page2.meta.pagination.links.prev + + assert ^page1 = + initial_conn + |> get(page2.meta.pagination.links.prev.url) + |> json_response(200) + |> assert_schema("Goal.ListResponse", spec()) + end + end + + describe "delete /goals/:id" do + test "deletes goal by id", %{conn: conn, site: site, token: token} do + {:ok, %{id: goal_id}} = + Plausible.Goals.create(site, %{"event_name" => "Purchase", "currency" => "USD"}) + + url = Routes.goals_url(base_uri(), :delete, goal_id) + + conn + |> authenticate(site.domain, token) + |> delete(url) + |> response(204) + end + + test "is idempotent", %{conn: conn, site: site, token: token} do + url = Routes.goals_url(base_uri(), :delete, 666) + + conn + |> authenticate(site.domain, token) + |> delete(url) + |> response(204) + end + end +end diff --git a/test/plausible_web/plugins/api/controllers/shared_links_test.exs b/test/plausible_web/plugins/api/controllers/shared_links_test.exs index 6e73365b4..437ade37c 100644 --- a/test/plausible_web/plugins/api/controllers/shared_links_test.exs +++ b/test/plausible_web/plugins/api/controllers/shared_links_test.exs @@ -1,23 +1,23 @@ defmodule PlausibleWeb.Plugins.API.Controllers.SharedLinksTest do use PlausibleWeb.PluginsAPICase, async: true - setup %{test: test} do - site = insert(:site) - {:ok, _token, raw_token} = Plausible.Plugins.API.Tokens.create(site, Atom.to_string(test)) - - {:ok, - %{ - site: site, - token: raw_token - }} + describe "examples" do + test "SharedLink" do + assert_schema( + Schemas.SharedLink.schema().example, + "SharedLink", + spec() + ) + end end - describe "unathorized calls" do + describe "unauthorized calls" do for {method, url} <- [ {:get, Routes.shared_links_url(base_uri(), :get, 1)}, - {:post, Routes.shared_links_url(base_uri(), :create)} + {:put, Routes.shared_links_url(base_uri(), :create)}, + {:get, Routes.shared_links_url(base_uri(), :index)} ] do - test "unauthorized call to #{url}", %{conn: conn} do + test "unauthorized call: #{method} #{url}", %{conn: conn} do conn |> unquote(method)(unquote(url)) |> json_response(401) @@ -52,12 +52,12 @@ defmodule PlausibleWeb.Plugins.API.Controllers.SharedLinksTest do |> json_response(200) |> assert_schema("SharedLink", spec()) - assert resp.data.href == + assert resp.shared_link.href == "http://localhost:8000/share/#{site.domain}?auth=#{shared_link.slug}" - assert resp.data.id == shared_link.id - assert resp.data.password_protected == false - assert resp.data.name == "Some Link Name" + assert resp.shared_link.id == shared_link.id + assert resp.shared_link.password_protected == false + assert resp.shared_link.name == "Some Link Name" end test "fails to retrieve non-existing link", %{conn: conn, site: site, token: token} do @@ -82,7 +82,7 @@ defmodule PlausibleWeb.Plugins.API.Controllers.SharedLinksTest do end end - describe "post /shared_links" do + describe "put /shared_links" do test "successfully creates a shared link with the location header", %{ conn: conn, site: site, @@ -95,8 +95,10 @@ defmodule PlausibleWeb.Plugins.API.Controllers.SharedLinksTest do conn = initial_conn |> put_req_header("content-type", "application/json") - |> post(url, %{ - name: "My Shared Link" + |> put(url, %{ + shared_link: %{ + name: "My Shared Link" + } }) resp = @@ -104,13 +106,13 @@ defmodule PlausibleWeb.Plugins.API.Controllers.SharedLinksTest do |> json_response(201) |> assert_schema("SharedLink", spec()) - assert resp.data.name == "My Shared Link" - assert resp.data.href =~ "http://localhost:8000/share/#{site.domain}?auth=" + assert resp.shared_link.name == "My Shared Link" + assert resp.shared_link.href =~ "http://localhost:8000/share/#{site.domain}?auth=" [location] = get_resp_header(conn, "location") assert location == - Routes.shared_links_url(base_uri(), :get, resp.data.id) + Routes.shared_links_url(base_uri(), :get, resp.shared_link.id) assert ^resp = initial_conn @@ -131,8 +133,10 @@ defmodule PlausibleWeb.Plugins.API.Controllers.SharedLinksTest do create = fn -> initial_conn |> put_req_header("content-type", "application/json") - |> post(url, %{ - name: "My Shared Link" + |> put(url, %{ + shared_link: %{ + name: "My Shared Link" + } }) end @@ -143,14 +147,14 @@ defmodule PlausibleWeb.Plugins.API.Controllers.SharedLinksTest do |> json_response(201) |> assert_schema("SharedLink", spec()) - id = resp.data.id + id = resp.shared_link.id conn = create.() assert ^id = conn |> json_response(201) - |> Map.fetch!("data") + |> Map.fetch!("shared_link") |> Map.fetch!("id") end @@ -161,11 +165,11 @@ defmodule PlausibleWeb.Plugins.API.Controllers.SharedLinksTest do conn |> authenticate(site.domain, token) |> put_req_header("content-type", "application/json") - |> post(url, %{}) + |> put(url, %{}) |> json_response(422) |> assert_schema("UnprocessableEntityError", spec()) - assert %{errors: [%{detail: "Missing field: name"}]} = resp + assert %{errors: [%{detail: "Missing field: shared_link"}]} = resp end end @@ -184,7 +188,7 @@ defmodule PlausibleWeb.Plugins.API.Controllers.SharedLinksTest do |> json_response(200) |> assert_schema("SharedLink.ListResponse", spec()) - assert resp.data == [] + assert resp.shared_links == [] assert resp.meta.pagination.has_next_page == false assert resp.meta.pagination.has_prev_page == false assert resp.meta.pagination.links == %{} @@ -209,7 +213,9 @@ defmodule PlausibleWeb.Plugins.API.Controllers.SharedLinksTest do |> json_response(200) |> assert_schema("SharedLink.ListResponse", spec()) - assert [%{data: %{name: "Shared Link 5"}}, %{data: %{name: "Shared Link 4"}}] = page1.data + assert [%{shared_link: %{name: "Shared Link 5"}}, %{shared_link: %{name: "Shared Link 4"}}] = + page1.shared_links + assert page1.meta.pagination.has_next_page == true assert page1.meta.pagination.has_prev_page == false assert page1.meta.pagination.links.next @@ -221,7 +227,8 @@ defmodule PlausibleWeb.Plugins.API.Controllers.SharedLinksTest do |> json_response(200) |> assert_schema("SharedLink.ListResponse", spec()) - assert [%{data: %{name: "Shared Link 3"}}, %{data: %{name: "Shared Link 2"}}] = page2.data + assert [%{shared_link: %{name: "Shared Link 3"}}, %{shared_link: %{name: "Shared Link 2"}}] = + page2.shared_links assert page2.meta.pagination.has_next_page == true assert page2.meta.pagination.has_prev_page == true diff --git a/test/plausible_web/plugins/api/errors_test.exs b/test/plausible_web/plugins/api/errors_test.exs index 344b60708..61fceefe4 100644 --- a/test/plausible_web/plugins/api/errors_test.exs +++ b/test/plausible_web/plugins/api/errors_test.exs @@ -37,5 +37,37 @@ defmodule PlausibleWeb.Plugins.API.ErrorsTest do "errors" => [%{"detail" => "Some message"}] } end + + defmodule Example do + use Ecto.Schema + import Ecto.Changeset + + schema "" do + field(:name) + field(:email) + field(:age, :integer) + end + + def changeset(example, params \\ %{}) do + example + |> cast(params, [:name, :email, :age]) + |> validate_required([:name, :email]) + |> validate_format(:email, ~r/@/) + |> validate_inclusion(:age, 18..100) + end + end + + test "formats changeset errors" do + changeset = Example.changeset(%Example{}, %{email: "foo", age: 101}) + + assert Plug.Test.conn(:get, "/") + |> Errors.error(:bad_request, changeset) + |> json_response(400) + |> Map.fetch!("errors") == [ + %{"detail" => "age: is invalid"}, + %{"detail" => "email: has invalid format"}, + %{"detail" => "name: can't be blank"} + ] + end end end diff --git a/test/support/plugins_api_case.ex b/test/support/plugins_api_case.ex index 21ce095fb..3a9eff271 100644 --- a/test/support/plugins_api_case.ex +++ b/test/support/plugins_api_case.ex @@ -17,11 +17,13 @@ defmodule PlausibleWeb.PluginsAPICase do import Phoenix.ConnTest import PlausibleWeb.Plugins.API, only: [base_uri: 0] import PlausibleWeb.Plugins.API.Spec, only: [spec: 0] - alias PlausibleWeb.Plugins.API.Router.Helpers, as: Routes import Plausible.Factory import OpenApiSpex.TestAssertions + alias PlausibleWeb.Plugins.API.Router.Helpers, as: Routes + alias PlausibleWeb.Plugins.API.Schemas + def authenticate(conn, domain, raw_token) do conn |> Plug.Conn.put_req_header( @@ -32,7 +34,8 @@ defmodule PlausibleWeb.PluginsAPICase do end end - setup tags do + setup %{test: test} = tags do + import Plausible.Factory :ok = Ecto.Adapters.SQL.Sandbox.checkout(Plausible.Repo) unless tags[:async] do @@ -41,6 +44,9 @@ defmodule PlausibleWeb.PluginsAPICase do conn = Phoenix.ConnTest.build_conn() - {:ok, conn: conn} + site = insert(:site) + {:ok, _token, raw_token} = Plausible.Plugins.API.Tokens.create(site, Atom.to_string(test)) + + {:ok, conn: conn, site: site, token: raw_token} end end