Cleanup files batch 360

extra/lib/plausible/installation_support/check.ex

@@ -1,61 +0,0 @@
-defmodule Plausible.InstallationSupport.Check do
-  @moduledoc """
-  Behaviour to be implemented by a specific installation support check.
-
-  `report_progress_as()` doesn't necessarily reflect the actual check
-  description, it serves as a user-facing message grouping mechanism,
-  to prevent frequent message flashing when checks rotate often.
-
-  Each check operates on `%Plausible.InstallationSupport.State{}` and is
-  expected to return it, optionally modified, by all means. `perform_safe/1`
-  is used to guarantee no exceptions are thrown by faulty implementations,
-  not to interrupt LiveView.
-  """
-  @type state() :: Plausible.InstallationSupport.State.t()
-  @callback report_progress_as() :: String.t()
-  @callback perform(state(), Keyword.t()) :: state()
-
-  defmacro __using__(_) do
-    quote do
-      import Plausible.InstallationSupport.State
-      alias Plausible.InstallationSupport.State
-
-      require Logger
-
-      @behaviour Plausible.InstallationSupport.Check
-
-      def perform_safe(state, opts) do
-        timeout = Keyword.get(opts, :timeout, 10_000)
-
-        task =
-          Task.async(fn ->
-            try do
-              perform(state, opts)
-            catch
-              _, e ->
-                Logger.error(
-                  "Error running check #{inspect(__MODULE__)} on #{state.url}: #{inspect(e)}"
-                )
-
-                put_diagnostics(state, service_error: %{code: :internal_check_error, extra: e})
-            end
-          end)
-
-        try do
-          Task.await(task, timeout)
-        catch
-          :exit, {:timeout, _} ->
-            Task.shutdown(task, :brutal_kill)
-            check_name = __MODULE__ |> Atom.to_string() |> String.split(".") |> List.last()
-
-            put_diagnostics(state,
-              service_error: %{
-                code: :internal_check_timeout,
-                extra: "#{check_name} timed out after #{timeout}ms"
-              }
-            )
-        end
-      end
-    end
-  end
-end

extra/lib/plausible/installation_support/check_runner.ex

@@ -1,65 +0,0 @@
-defmodule Plausible.InstallationSupport.CheckRunner do
-  @moduledoc """
-  Takes two arguments:
-
-  1. A `%Plausible.InstallationSupport.State{}` struct - the `diagnostics`
-     field is a struct representing the set of diagnostics shared between
-     all the checks in this flow.
-
-  2. A list of modules implementing `Plausible.InstallationSupport.Check`
-     behaviour.
-
-  Checks are normally run asynchronously, except when synchronous
-  execution is optionally required for tests. Slowdowns can be optionally
-  added, the user doesn't benefit from running the checks too quickly.
-  """
-
-  def run(state, checks, opts) do
-    async? = Keyword.get(opts, :async?, true)
-    slowdown = Keyword.get(opts, :slowdown, 500)
-
-    if async? do
-      Task.start_link(fn -> do_run(state, checks, slowdown) end)
-    else
-      do_run(state, checks, slowdown)
-    end
-  end
-
-  defp do_run(state, checks, slowdown) do
-    state =
-      Enum.reduce_while(
-        checks,
-        state,
-        fn {check, check_opts}, state ->
-          if state.skip_further_checks? do
-            {:halt, state}
-          else
-            {:cont,
-             state
-             |> notify_check_start(check, slowdown)
-             |> check.perform_safe(check_opts)}
-          end
-        end
-      )
-
-    notify_all_checks_done(state, slowdown)
-  end
-
-  defp notify_check_start(state, check, slowdown) do
-    if is_pid(state.report_to) do
-      if is_integer(slowdown) and slowdown > 0, do: :timer.sleep(slowdown)
-      send(state.report_to, {:check_start, {check, state}})
-    end
-
-    state
-  end
-
-  defp notify_all_checks_done(state, slowdown) do
-    if is_pid(state.report_to) do
-      if is_integer(slowdown) and slowdown > 0, do: :timer.sleep(slowdown)
-      send(state.report_to, {:all_checks_done, state})
-    end
-
-    state
-  end
-end

extra/lib/plausible/installation_support/checks/detection.ex

@@ -1,162 +0,0 @@
-defmodule Plausible.InstallationSupport.Checks.Detection do
-  @moduledoc """
-  Calls the browserless.io service (local instance can be spawned with `make browserless`)
-  and runs detector script via the [function API](https://docs.browserless.io/HTTP-APIs/function).
-
-  * v1_detected (optional - detection can take up to @plausible_window_check_timeout_ms)
-  * gtm_likely
-  * wordpress_likely
-  * wordpress_plugin
-
-  These diagnostics are used to determine what installation type to recommend,
-  and whether to provide a notice for upgrading an existing v1 integration to v2.
-  """
-
-  require Logger
-  use Plausible.InstallationSupport.Check
-  alias Plausible.InstallationSupport.BrowserlessConfig
-
-  @detector_code_path "priv/tracker/installation_support/detector.js"
-  @external_resource @detector_code_path
-
-  # On CI, the file might not be present for static checks so we default to empty string
-  @detector_code (case File.read(Application.app_dir(:plausible, @detector_code_path)) do
-                    {:ok, content} -> content
-                    {:error, _} -> ""
-                  end)
-
-  # Puppeteer wrapper function that executes the vanilla JS detector code
-  @puppeteer_wrapper_code """
-  export default async function({ page, context: { url, userAgent, ...functionContext } }) {
-    try {
-      await page.setUserAgent(userAgent);
-      await page.goto(url);
-
-      await page.evaluate(() => {
-        #{@detector_code} // injects window.scanPageBeforePlausibleInstallation
-      });
-
-      return await page.evaluate(
-        (c) => window.scanPageBeforePlausibleInstallation(c),
-        { ...functionContext }
-      );
-    } catch (error) {
-      return {
-        data: {
-          completed: false,
-          error: {
-            message: error?.message ?? JSON.stringify(error)
-          }
-        }
-      }
-    }
-  }
-  """
-
-  # This timeout determines how long we wait for window.plausible to be initialized on the page, used for detecting whether v1 installed
-  @plausible_window_check_timeout_ms 1_500
-
-  # To support browserless API being unavailable or overloaded, we retry the endpoint call if it doesn't return a successful response
-  @max_retries 1
-
-  @impl true
-  def report_progress_as, do: "We're checking your site to recommend the best installation method"
-
-  @impl true
-  def perform(%State{url: url, assigns: %{detect_v1?: detect_v1?}} = state, opts) do
-    check_timeout = Keyword.fetch!(opts, :timeout)
-
-    # We rely on Req's `:receive_timeout` to avoid waiting too long for a response, but
-    # we also pass the same timeout (+ 1s) via a query param to the Browserless /function API
-    # to not waste resources and leave a redundant process running there.
-    req_timeout = check_timeout - 1000
-    browserless_api_timeout = check_timeout
-
-    opts =
-      [
-        headers: %{content_type: "application/json"},
-        body:
-          Jason.encode!(%{
-            code: @puppeteer_wrapper_code,
-            context: %{
-              url: Plausible.InstallationSupport.URL.bust_url(url),
-              userAgent: Plausible.InstallationSupport.user_agent(),
-              detectV1: detect_v1?,
-              timeoutMs: @plausible_window_check_timeout_ms,
-              debug: Application.get_env(:plausible, :environment) == "dev"
-            }
-          }),
-        params: %{timeout: browserless_api_timeout},
-        retry: fn _request, response_or_error ->
-          case response_or_error do
-            %{status: status} -> Map.get(BrowserlessConfig.retry_policy(), status, false)
-            _ -> false
-          end
-        end,
-        receive_timeout: req_timeout,
-        retry_log_level: :warning,
-        max_retries: @max_retries
-      ]
-      |> Keyword.merge(Application.get_env(:plausible, __MODULE__)[:req_opts] || [])
-
-    case Req.post(BrowserlessConfig.browserless_function_api_endpoint(), opts) do
-      {:ok, %{body: body, status: status}} ->
-        handle_browserless_response(state, body, status)
-
-      {:error, %Req.TransportError{reason: :timeout}} ->
-        put_diagnostics(state, service_error: %{code: :browserless_timeout})
-
-      {:error, %{reason: reason}} ->
-        Logger.warning(warning_message("Browserless request error: #{inspect(reason)}", state))
-
-        put_diagnostics(state, service_error: %{code: :req_error, extra: reason})
-    end
-  end
-
-  defp handle_browserless_response(
-         state,
-         %{"data" => %{"completed" => completed} = data},
-         _status
-       ) do
-    if completed do
-      put_diagnostics(
-        state,
-        parse_to_diagnostics(data)
-      )
-    else
-      Logger.warning(
-        warning_message(
-          "Browserless function returned with completed: false, error.message: #{inspect(data["error"]["message"])}",
-          state
-        )
-      )
-
-      put_diagnostics(state,
-        service_error: %{code: :browserless_client_error, extra: data["error"]["message"]}
-      )
-    end
-  end
-
-  defp handle_browserless_response(state, body, status) do
-    error = "Unhandled browserless response with status: #{status}"
-
-    warning_message("#{error}; body: #{inspect(body)}", state)
-    |> Logger.warning()
-
-    put_diagnostics(state, service_error: %{code: :bad_browserless_response, extra: status})
-  end
-
-  defp warning_message(message, state) do
-    "[DETECTION] #{message} (data_domain='#{state.data_domain}')"
-  end
-
-  defp parse_to_diagnostics(data),
-    do: [
-      v1_detected: data["v1Detected"],
-      gtm_likely: data["gtmLikely"],
-      npm: data["npm"],
-      wordpress_likely: data["wordpressLikely"],
-      wordpress_plugin: data["wordpressPlugin"],
-      service_error: nil
-    ]
-end

extra/lib/plausible/installation_support/checks/url.ex

@@ -1,103 +0,0 @@
-defmodule Plausible.InstallationSupport.Checks.Url do
-  @moduledoc """
-  Checks if site domain has an A record.
-  If not, checks if prepending `www.` helps,
-  because we have specifically requested customers to register the domain with `www.` prefix.
-  If not, skips all further checks.
-  """
-
-  use Plausible.InstallationSupport.Check
-
-  @impl true
-  def report_progress_as, do: "We're trying to reach your website"
-
-  @impl true
-  @spec perform(State.t(), Keyword.t()) :: State.t()
-  def perform(%State{url: url} = state, _opts) when is_binary(url) do
-    with {:ok, %URI{scheme: scheme} = uri} when scheme in ["http", "https"] <- URI.new(url),
-         :ok <- check_domain(uri.host) do
-      stripped_url = URI.to_string(%URI{uri | query: nil, fragment: nil})
-      %State{state | url: stripped_url}
-    else
-      {:error, :no_a_record} ->
-        put_diagnostics(%State{state | skip_further_checks?: true},
-          service_error: %{code: :domain_not_found}
-        )
-
-      _ ->
-        put_diagnostics(%State{state | skip_further_checks?: true},
-          service_error: %{code: :invalid_url}
-        )
-    end
-  end
-
-  def perform(%State{data_domain: domain} = state, _opts) when is_binary(domain) do
-    case find_working_url(domain) do
-      {:ok, working_url} ->
-        %State{state | url: working_url}
-
-      {:error, :domain_not_found} ->
-        put_diagnostics(%State{state | url: nil, skip_further_checks?: true},
-          service_error: %{code: :domain_not_found}
-        )
-    end
-  end
-
-  # Check A records of the the domains [domain, "www.#{domain}"]
-  # at this point, domain can contain path
-  @spec find_working_url(String.t()) :: {:ok, String.t()} | {:error, :domain_not_found}
-  defp find_working_url(domain) do
-    [domain_without_path | rest] = split_domain(domain)
-
-    [
-      domain_without_path,
-      "www.#{domain_without_path}"
-    ]
-    |> Enum.reduce_while({:error, :domain_not_found}, fn d, _acc ->
-      case dns_lookup(d) do
-        :ok -> {:halt, {:ok, "https://" <> unsplit_domain(d, rest)}}
-        {:error, :no_a_record} -> {:cont, {:error, :domain_not_found}}
-      end
-    end)
-  end
-
-  @spec dns_lookup(String.t()) :: :ok | {:error, :no_a_record}
-  defp dns_lookup(domain) do
-    lookup_timeout = 1_000
-    resolve_timeout = 1_000
-
-    case Plausible.DnsLookup.impl().lookup(
-           to_charlist(domain),
-           :in,
-           :a,
-           [timeout: resolve_timeout],
-           lookup_timeout
-         ) do
-      [{a, b, c, d} | _]
-      when is_integer(a) and is_integer(b) and is_integer(c) and is_integer(d) ->
-        :ok
-
-      # this may mean timeout or no DNS record
-      [] ->
-        {:error, :no_a_record}
-    end
-  end
-
-  defp check_domain(domain) do
-    if Application.get_env(:plausible, :environment) == "dev" and domain == "localhost" do
-      :ok
-    else
-      dns_lookup(domain)
-    end
-  end
-
-  @spec split_domain(String.t()) :: [String.t()]
-  defp split_domain(domain) do
-    String.split(domain, "/", parts: 2)
-  end
-
-  @spec unsplit_domain(String.t(), [String.t()]) :: String.t()
-  defp unsplit_domain(domain_without_path, rest) do
-    Enum.join([domain_without_path] ++ rest, "/")
-  end
-end

extra/lib/plausible/installation_support/checks/verify_installation.ex

@@ -1,189 +0,0 @@
-defmodule Plausible.InstallationSupport.Checks.VerifyInstallation do
-  @moduledoc """
-  Calls the browserless.io service (local instance can be spawned with `make browserless`)
-  and runs verifier script via the [function API](https://docs.browserless.io/HTTP-APIs/function).
-  """
-
-  require Logger
-  use Plausible.InstallationSupport.Check
-  alias Plausible.InstallationSupport.BrowserlessConfig
-
-  @verifier_code_path "priv/tracker/installation_support/verifier.js"
-  @external_resource @verifier_code_path
-
-  # On CI, the file might not be present for static checks so we default to empty string
-  @verifier_code (case File.read(Application.app_dir(:plausible, @verifier_code_path)) do
-                    {:ok, content} -> content
-                    {:error, _} -> ""
-                  end)
-
-  # Puppeteer wrapper function that executes the vanilla JS verifier code
-  @puppeteer_wrapper_code """
-  export default async function({ page, context: { url, userAgent, maxAttempts, timeoutBetweenAttemptsMs, ...functionContext } }) {
-    try {
-      await page.setUserAgent(userAgent)
-      const response = await page.goto(url)
-      const responseStatus = response.status()
-      const responseHeaders = response.headers()
-
-      async function verify() {
-        await page.evaluate(() => {#{@verifier_code}}) // injects window.verifyPlausibleInstallation
-        return await page.evaluate(
-          (c) => window.verifyPlausibleInstallation(c),
-          { ...functionContext, responseHeaders }
-        );
-      }
-
-      let lastError;
-      for (let attempts = 1; attempts <= maxAttempts; attempts++) {
-        try {
-          const output = await verify();
-          return {
-            data: {
-              ...output.data,
-              attempts,
-              responseStatus
-            },
-          };
-        } catch (error) {
-          lastError = error;
-          if (
-            typeof error?.message === "string" &&
-            error.message.toLowerCase().includes("execution context")
-          ) {
-            await new Promise((resolve) => setTimeout(resolve, timeoutBetweenAttemptsMs));
-            continue;
-          }
-          throw error
-        }
-      }
-      throw lastError;
-    } catch (error) {
-      return {
-        data: {
-          completed: false,
-          error: {
-            message: error?.message ?? JSON.stringify(error)
-          }
-        }
-      }
-    }
-  }
-  """
-
-  # To support browserless API being unavailable or overloaded, we retry the endpoint call if it doesn't return a successful response
-  @max_retries 1
-
-  # We rely on Req's `:receive_timeout` to avoid waiting too long for a response. We also pass the same timeout (+ 1s) via a query
-  # param to the Browserless /function API to not waste resources.
-  @req_timeout 15_000
-
-  # This timeout determines how long we wait for window.plausible to be initialized on the page, including sending the test event
-  @plausible_window_check_timeout_ms 4_000
-
-  # To handle navigation that happens immediately on the page, we attempt to verify the installation multiple times _within a single browserless endpoint call_
-  @max_attempts 2
-  @timeout_between_attempts_ms 500
-
-  @impl true
-  def report_progress_as, do: "We're verifying that your visitors are being counted correctly"
-
-  @impl true
-  def perform(%State{url: url} = state, _opts) do
-    opts = [
-      headers: %{content_type: "application/json"},
-      body:
-        JSON.encode!(%{
-          code: @puppeteer_wrapper_code,
-          context: %{
-            maxAttempts: @max_attempts,
-            timeoutMs: @plausible_window_check_timeout_ms,
-            timeoutBetweenAttemptsMs: @timeout_between_attempts_ms,
-            cspHostToCheck: PlausibleWeb.Endpoint.host(),
-            url: url,
-            userAgent: Plausible.InstallationSupport.user_agent(),
-            debug: Application.get_env(:plausible, :environment) == "dev"
-          }
-        }),
-      params: %{timeout: @req_timeout + 1000},
-      retry: fn _request, response_or_error ->
-        case response_or_error do
-          %{status: status} -> Map.get(BrowserlessConfig.retry_policy(), status, false)
-          %Req.TransportError{reason: :timeout} -> {:delay, 500}
-          _ -> false
-        end
-      end,
-      retry_log_level: :warning,
-      max_retries: @max_retries,
-      receive_timeout: @req_timeout
-    ]
-
-    extra_opts = Application.get_env(:plausible, __MODULE__)[:req_opts] || []
-    opts = Keyword.merge(opts, extra_opts)
-
-    case Req.post(BrowserlessConfig.browserless_function_api_endpoint(), opts) do
-      {:ok, %{body: body, status: status}} ->
-        handle_browserless_response(state, body, status)
-
-      {:error, %Req.TransportError{reason: :timeout}} ->
-        put_diagnostics(state, service_error: %{code: :browserless_timeout})
-
-      {:error, %{reason: reason}} ->
-        Logger.warning(warning_message("Browserless request error: #{inspect(reason)}", state))
-
-        put_diagnostics(state, service_error: %{code: :req_error, extra: reason})
-    end
-  end
-
-  defp handle_browserless_response(
-         state,
-         %{"data" => %{"completed" => completed} = data},
-         _status
-       ) do
-    if completed do
-      put_diagnostics(
-        state,
-        parse_to_diagnostics(data)
-      )
-    else
-      Logger.warning(
-        warning_message(
-          "Browserless function returned with completed: false, error.message: #{inspect(data["error"]["message"])}",
-          state
-        )
-      )
-
-      put_diagnostics(state,
-        service_error: %{code: :browserless_client_error, extra: data["error"]["message"]}
-      )
-    end
-  end
-
-  defp handle_browserless_response(state, body, status) do
-    error = "Unhandled browserless response with status: #{status}"
-
-    warning_message("#{error}; body: #{inspect(body)}", state)
-    |> Logger.warning()
-
-    put_diagnostics(state, service_error: %{code: :bad_browserless_response, extra: status})
-  end
-
-  defp warning_message(message, state) do
-    "[VERIFICATION] #{message} (data_domain='#{state.data_domain}')"
-  end
-
-  defp parse_to_diagnostics(data),
-    do: [
-      disallowed_by_csp: data["disallowedByCsp"],
-      tracker_is_in_html: data["trackerIsInHtml"],
-      plausible_is_on_window: data["plausibleIsOnWindow"],
-      plausible_is_initialized: data["plausibleIsInitialized"],
-      plausible_version: data["plausibleVersion"],
-      plausible_variant: data["plausibleVariant"],
-      test_event: data["testEvent"],
-      cookies_consent_result: data["cookiesConsentResult"],
-      attempts: data["attempts"],
-      response_status: data["responseStatus"],
-      service_error: nil
-    ]
-end

extra/lib/plausible/installation_support/checks/verify_installation_cache_bust.ex

@@ -1,42 +0,0 @@
-defmodule Plausible.InstallationSupport.Checks.VerifyInstallationCacheBust do
-  @moduledoc """
-  If the output of previous checks can not be interpreted as successful,
-  as a last resort, we try to bust the cache of the site under test by adding a query parameter to the URL,
-  and running VerifyInstallation again.
-
-  Whatever the result from the rerun, that is what we use to interpret the installation.
-
-  The idea is to make sure that any issues we detect will be about the latest version of their website.
-
-  We also want to avoid reporting a successful installation if it took a special cache-busting action to make it work.
-  """
-
-  require Logger
-  alias Plausible.InstallationSupport
-  use Plausible.InstallationSupport.Check
-
-  @impl true
-  def report_progress_as, do: "We're verifying that your visitors are being counted correctly"
-
-  @impl true
-  def perform(%State{url: url} = state, _opts) do
-    case InstallationSupport.Verification.Checks.interpret_diagnostics(state, telemetry?: false) do
-      %InstallationSupport.Result{ok?: true} ->
-        state
-
-      %InstallationSupport.Result{data: %{unhandled: true}} ->
-        state
-
-      _known_installation_failure ->
-        reset_diagnostics = %InstallationSupport.Verification.Diagnostics{
-          selected_installation_type: state.diagnostics.selected_installation_type
-        }
-
-        state
-        |> struct!(diagnostics: reset_diagnostics)
-        |> struct!(url: InstallationSupport.URL.bust_url(url))
-        |> InstallationSupport.Checks.VerifyInstallation.perform([])
-        |> put_diagnostics(diagnostics_are_from_cache_bust: true)
-    end
-  end
-end

extra/lib/plausible/installation_support/detection/checks.ex

@@ -1,114 +0,0 @@
-defmodule Plausible.InstallationSupport.Detection.Checks do
-  @moduledoc """
-  Checks that are performed pre-installation, providing recommended installation
-  methods and whether v1 is used on the site.
-
-  In async execution, each check notifies the caller by sending a message to it.
-  """
-  alias Plausible.InstallationSupport.Detection
-  alias Plausible.InstallationSupport.{State, CheckRunner, Checks}
-
-  require Logger
-
-  @detection_check_timeout 6000
-
-  def run(url, data_domain, opts \\ []) do
-    detection_check_timeout =
-      case Keyword.get(opts, :detection_check_timeout) do
-        int when is_integer(int) -> int
-        _ -> @detection_check_timeout
-      end
-
-    report_to = Keyword.get(opts, :report_to, self())
-    async? = Keyword.get(opts, :async?, true)
-    slowdown = Keyword.get(opts, :slowdown, 500)
-    detect_v1? = Keyword.get(opts, :detect_v1?, false)
-
-    init_state =
-      %State{
-        url: url,
-        data_domain: data_domain,
-        report_to: report_to,
-        diagnostics: %Detection.Diagnostics{},
-        assigns: %{detect_v1?: detect_v1?}
-      }
-
-    checks = [
-      {Checks.Url, []},
-      {Checks.Detection, [timeout: detection_check_timeout]}
-    ]
-
-    CheckRunner.run(init_state, checks,
-      async?: async?,
-      report_to: report_to,
-      slowdown: slowdown
-    )
-  end
-
-  def telemetry_event_success(), do: [:plausible, :detection, :success]
-  def telemetry_event_failure(), do: [:plausible, :detection, :failure]
-
-  def interpret_diagnostics(%State{
-        diagnostics: diagnostics,
-        data_domain: data_domain,
-        url: url
-      }) do
-    result = Detection.Diagnostics.interpret(diagnostics, url)
-
-    {failed?, trigger_sentry?, msg} =
-      case result do
-        %{ok?: true} ->
-          {false, false, nil}
-
-        %{data: %{failure: :customer_website_issue}} ->
-          {true, false, "Failed due to an issue with the customer website"}
-
-        %{data: %{failure: :browserless_issue}} ->
-          {true, true, "Failed due to a Browserless issue"}
-
-        _unknown_failure ->
-          {true, true, "Unknown failure"}
-      end
-
-    if failed? do
-      :telemetry.execute(telemetry_event_failure(), %{})
-      Logger.warning("[DETECTION] #{msg} (data_domain='#{data_domain}'): #{inspect(diagnostics)}")
-    else
-      :telemetry.execute(telemetry_event_success(), %{})
-    end
-
-    if trigger_sentry? do
-      Sentry.capture_message("[DETECTION] #{msg}",
-        extra: %{
-          message: inspect(diagnostics),
-          url: url,
-          hash: :erlang.phash2(diagnostics)
-        }
-      )
-    end
-
-    result
-  end
-
-  @unthrottled_checks 3
-  @first_slowdown_ms 1000
-  def run_with_rate_limit(url, data_domain, opts \\ []) do
-    case Plausible.RateLimit.check_rate(
-           "site_detection:#{data_domain}",
-           :timer.minutes(60),
-           10
-         ) do
-      {:allow, count} when count <= @unthrottled_checks ->
-        {:ok, run(url, data_domain, opts)}
-
-      {:allow, count} when count > @unthrottled_checks ->
-        # slowdown steps 1x, 4x, 9x, 16x, ...
-        slowdown_ms = @first_slowdown_ms * (count - @unthrottled_checks) ** 2
-        :timer.sleep(slowdown_ms)
-        {:ok, run(url, data_domain, opts)}
-
-      {:deny, limit} ->
-        {:error, {:rate_limit_exceeded, limit}}
-    end
-  end
-end

extra/lib/plausible/installation_support/detection/diagnostics.ex

@@ -1,108 +0,0 @@
-defmodule Plausible.InstallationSupport.Detection.Diagnostics do
-  @moduledoc """
-  Module responsible for translating diagnostics to user-friendly errors and recommendations.
-  """
-
-  # in this struct, nil means indeterminate
-  defstruct v1_detected: nil,
-            gtm_likely: nil,
-            wordpress_likely: nil,
-            wordpress_plugin: nil,
-            npm: nil,
-            service_error: nil
-
-  @type t :: %__MODULE__{}
-
-  alias Plausible.InstallationSupport.Result
-
-  @spec interpret(t(), String.t()) :: Result.t()
-  def interpret(
-        %__MODULE__{
-          gtm_likely: true,
-          service_error: nil
-        } = diagnostics,
-        _url
-      ) do
-    success("gtm", diagnostics)
-  end
-
-  def interpret(
-        %__MODULE__{
-          wordpress_likely: true,
-          service_error: nil
-        } = diagnostics,
-        _url
-      ) do
-    success(
-      "wordpress",
-      diagnostics
-    )
-  end
-
-  def interpret(
-        %__MODULE__{
-          npm: true,
-          service_error: nil
-        } = diagnostics,
-        _url
-      ) do
-    success("npm", diagnostics)
-  end
-
-  def interpret(
-        %__MODULE__{
-          service_error: nil
-        } = diagnostics,
-        _url
-      ) do
-    success(PlausibleWeb.Tracker.fallback_installation_type(), diagnostics)
-  end
-
-  def interpret(%__MODULE__{service_error: %{code: code}}, _url)
-      when code in [:domain_not_found, :invalid_url] do
-    failure(:customer_website_issue)
-  end
-
-  def interpret(%__MODULE__{service_error: %{code: code}}, _url)
-      when code in [:bad_browserless_response, :browserless_timeout, :internal_check_timeout] do
-    failure(:browserless_issue)
-  end
-
-  def interpret(
-        %__MODULE__{service_error: %{code: :browserless_client_error, extra: extra}},
-        _url
-      ) do
-    cond do
-      String.contains?(extra, "net::") ->
-        failure(:customer_website_issue)
-
-      String.contains?(String.downcase(extra), "execution context") ->
-        failure(:customer_website_issue)
-
-      true ->
-        failure(:unknown_issue)
-    end
-  end
-
-  def interpret(%__MODULE__{} = _diagnostics, _url), do: failure(:unknown_issue)
-
-  defp failure(reason) do
-    %Result{
-      ok?: false,
-      data: %{failure: reason},
-      errors: [reason]
-    }
-  end
-
-  defp success(suggested_technology, diagnostics) do
-    %Result{
-      ok?: true,
-      data: %{
-        v1_detected: diagnostics.v1_detected,
-        wordpress_plugin: diagnostics.wordpress_plugin,
-        npm: diagnostics.npm,
-        suggested_technology: suggested_technology
-      }
-    }
-  end
-end

extra/lib/plausible/installation_support/installation_support.ex

@@ -1,20 +0,0 @@
-defmodule Plausible.InstallationSupport do
-  @moduledoc """
-  This top level module is the middle ground between pre-installation
-  site scans and verification of whether Plausible has been installed
-  correctly.
-
-  Defines the user-agent used with checks.
-  """
-  use Plausible
-
-  on_ee do
-    def user_agent() do
-      "Plausible Verification Agent - if abused, contact support@plausible.io"
-    end
-  else
-    def user_agent() do
-      "Plausible Community Edition"
-    end
-  end
-end

extra/lib/plausible/installation_support/result.ex

@@ -1,18 +0,0 @@
-defmodule Plausible.InstallationSupport.Result do
-  @moduledoc """
-  Diagnostics interpretation result.
-
-  ## Example
-  ok?: false,
-  data: nil,
-  errors: [error.message],
-  recommendations: [%{text: error.recommendation, url: error.url}]
-
-  ok?: true,
-  data: %{},
-  errors: [],
-  recommendations: []
-  """
-  defstruct ok?: false, errors: [], recommendations: [], data: nil
-  @type t :: %__MODULE__{}
-end

extra/lib/plausible/installation_support/state.ex

@@ -1,40 +0,0 @@
-defmodule Plausible.InstallationSupport.State do
-  @moduledoc """
-  The state to be shared across check during site installation support.
-
-  Assigns are meant to be used to communicate between checks, while
-  `diagnostics` are specific to the check group being executed.
-  """
-
-  defstruct url: nil,
-            data_domain: nil,
-            report_to: nil,
-            assigns: %{},
-            diagnostics: %{},
-            skip_further_checks?: false
-
-  @type diagnostics_type ::
-          Plausible.InstallationSupport.Verification.Diagnostics.t()
-          | Plausible.InstallationSupport.Detection.Diagnostics.t()
-
-  @type t :: %__MODULE__{
-          url: String.t() | nil,
-          data_domain: String.t() | nil,
-          report_to: pid() | nil,
-          assigns: map(),
-          diagnostics: diagnostics_type(),
-          skip_further_checks?: boolean()
-        }
-
-  def assign(%__MODULE__{} = state, assigns) do
-    %{state | assigns: Map.merge(state.assigns, Enum.into(assigns, %{}))}
-  end
-
-  def put_diagnostics(%__MODULE__{} = state, diagnostics) when is_list(diagnostics) do
-    %{state | diagnostics: struct!(state.diagnostics, diagnostics)}
-  end
-
-  def put_diagnostics(%__MODULE__{} = state, diagnostics) do
-    put_diagnostics(state, List.wrap(diagnostics))
-  end
-end

extra/lib/plausible/installation_support/url.ex

@@ -1,25 +0,0 @@
-defmodule Plausible.InstallationSupport.URL do
-  @moduledoc """
-  URL utilities for installation support, including cache busting functionality.
-  """
-
-  def bust_url(url) do
-    cache_invalidator = abs(:erlang.unique_integer())
-    update_url(url, cache_invalidator)
-  end
-
-  defp update_url(url, invalidator) do
-    url
-    |> URI.parse()
-    |> then(fn uri ->
-      updated_query =
-        (uri.query || "")
-        |> URI.decode_query()
-        |> Map.put("plausible_verification", invalidator)
-        |> URI.encode_query()
-
-      struct!(uri, query: updated_query)
-    end)
-    |> to_string()
-  end
-end

extra/lib/plausible/installation_support/verification/checks.ex

@@ -1,100 +0,0 @@
-defmodule Plausible.InstallationSupport.Verification.Checks do
-  @moduledoc """
-  Checks that are performed during tracker script installation verification.
-
-  In async execution, each check notifies the caller by sending a message to it.
-  """
-  alias Plausible.InstallationSupport.Verification
-  alias Plausible.InstallationSupport.{State, CheckRunner, Checks}
-
-  require Logger
-
-  @verify_installation_check_timeout 20_000
-
-  @spec run(String.t(), String.t(), String.t(), Keyword.t()) :: {:ok, pid()} | State.t()
-  def run(url, data_domain, installation_type, opts \\ []) do
-    # Timeout option for testing purposes
-    verify_installation_check_timeout =
-      case Keyword.get(opts, :verify_installation_check_timeout) do
-        int when is_integer(int) -> int
-        _ -> @verify_installation_check_timeout
-      end
-
-    report_to = Keyword.get(opts, :report_to, self())
-    async? = Keyword.get(opts, :async?, true)
-    slowdown = Keyword.get(opts, :slowdown, 500)
-
-    init_state =
-      %State{
-        url: url,
-        data_domain: data_domain,
-        report_to: report_to,
-        diagnostics: %Verification.Diagnostics{
-          selected_installation_type: installation_type
-        }
-      }
-
-    checks = [
-      {Checks.Url, []},
-      {Checks.VerifyInstallation, [timeout: verify_installation_check_timeout]},
-      {Checks.VerifyInstallationCacheBust, [timeout: verify_installation_check_timeout]}
-    ]
-
-    CheckRunner.run(init_state, checks,
-      async?: async?,
-      report_to: report_to,
-      slowdown: slowdown
-    )
-  end
-
-  def telemetry_event_handled(), do: [:plausible, :verification, :handled]
-  def telemetry_event_unhandled(), do: [:plausible, :verification, :unhandled]
-
-  def interpret_diagnostics(
-        %State{
-          diagnostics: diagnostics,
-          data_domain: data_domain,
-          url: url
-        },
-        opts \\ []
-      ) do
-    telemetry? = Keyword.get(opts, :telemetry?, true)
-
-    result =
-      Verification.Diagnostics.interpret(
-        diagnostics,
-        data_domain,
-        url
-      )
-
-    case {telemetry?, result.data} do
-      {false, _} ->
-        :skip
-
-      {_, %{unhandled: true, browserless_issue: browserless_issue}} ->
-        sentry_msg =
-          if browserless_issue,
-            do: "Browserless failure in verification",
-            else: "Unhandled case for site verification"
-
-        Sentry.capture_message(sentry_msg,
-          extra: %{
-            message: inspect(diagnostics),
-            url: url,
-            hash: :erlang.phash2(diagnostics)
-          }
-        )
-
-        Logger.warning(
-          "[VERIFICATION] Unhandled case (data_domain='#{data_domain}'): #{inspect(diagnostics)}"
-        )
-
-        :telemetry.execute(telemetry_event_unhandled(), %{})
-
-      _ ->
-        :telemetry.execute(telemetry_event_handled(), %{})
-    end
-
-    result
-  end
-end

extra/lib/plausible/installation_support/verification/diagnostics.ex

@@ -1,389 +0,0 @@
-defmodule Plausible.InstallationSupport.Verification.Diagnostics do
-  @moduledoc """
-  Module responsible for translating diagnostics to user-friendly errors and recommendations.
-  """
-
-  # In this struct
-  # - the default nil value for each field means that the value is indeterminate (e.g. we didn't even get to the part where response_status is set)
-  defstruct [
-    :selected_installation_type,
-    :disallowed_by_csp,
-    :tracker_is_in_html,
-    :plausible_is_on_window,
-    :plausible_is_initialized,
-    :plausible_version,
-    :plausible_variant,
-    :diagnostics_are_from_cache_bust,
-    :test_event,
-    :cookies_consent_result,
-    :response_status,
-    :service_error,
-    :attempts
-  ]
-
-  @type t :: %__MODULE__{}
-
-  @verify_manually_url "https://plausible.io/docs/troubleshoot-integration#how-to-manually-check-your-integration"
-
-  alias Plausible.InstallationSupport.Result
-
-  defmodule Error do
-    @moduledoc """
-    Error that has compile-time enforced checks for the attributes.
-    """
-
-    @enforce_keys [:message, :recommendation]
-    defstruct [:message, :recommendation, :url]
-
-    def new!(attrs) do
-      message = Map.fetch!(attrs, :message)
-
-      if String.ends_with?(message, ".") do
-        raise ArgumentError, "Error message must not end with a period: #{inspect(message)}"
-      end
-
-      if String.ends_with?(attrs[:recommendation], ".") do
-        raise ArgumentError,
-              "Error recommendation must not end with a period: #{inspect(attrs[:recommendation])}"
-      end
-
-      if is_binary(attrs[:url]) and not String.starts_with?(attrs[:url], "https://plausible.io") do
-        raise ArgumentError,
-              "Recommendation url must start with 'https://plausible.io': #{inspect(attrs[:url])}"
-      end
-
-      struct!(__MODULE__, attrs)
-    end
-  end
-
-  @error_succeeds_only_after_cache_bust Error.new!(%{
-                                          message: "We detected an issue with your site's cache",
-                                          recommendation:
-                                            "Please clear the cache for your site to ensure that your visitors will load the latest version of your site that has Plausible correctly installed",
-                                          url:
-                                            "https://plausible.io/docs/troubleshoot-integration#have-you-cleared-the-cache-of-your-site"
-                                        })
-
-  @spec interpret(t(), String.t(), String.t()) :: Result.t()
-  def interpret(
-        %__MODULE__{
-          test_event: %{
-            "normalizedBody" => %{
-              "domain" => domain
-            },
-            "responseStatus" => response_status
-          },
-          service_error: nil,
-          diagnostics_are_from_cache_bust: true
-        },
-        expected_domain,
-        _url
-      )
-      when response_status in [200, 202] and
-             domain == expected_domain,
-      do: handled_error(@error_succeeds_only_after_cache_bust)
-
-  def interpret(
-        %__MODULE__{
-          test_event: %{
-            "normalizedBody" => %{
-              "domain" => domain
-            },
-            "responseStatus" => response_status
-          },
-          service_error: nil
-        },
-        expected_domain,
-        _url
-      )
-      when response_status in [200, 202] and
-             domain == expected_domain,
-      do: success()
-
-  def interpret(
-        %__MODULE__{
-          test_event: %{
-            "normalizedBody" => %{
-              "domain" => domain
-            },
-            "responseStatus" => response_status
-          },
-          service_error: nil,
-          selected_installation_type: selected_installation_type
-        },
-        expected_domain,
-        _url
-      )
-      when response_status in [200, 202] and
-             domain != expected_domain do
-    error_unexpected_domain(selected_installation_type)
-    |> handled_error()
-  end
-
-  @error_proxy_network_error Error.new!(%{
-                               message:
-                                 "We got an unexpected response from the proxy you are using for Plausible",
-                               recommendation:
-                                 "Please check that you've configured the proxied /event route correctly",
-                               url: "https://plausible.io/docs/proxy/introduction"
-                             })
-  @error_plausible_network_error Error.new!(%{
-                                   message: "We couldn't verify your website",
-                                   recommendation:
-                                     "Please try verifying again in a few minutes, or verify your installation manually",
-                                   url: @verify_manually_url
-                                 })
-
-  def interpret(
-        %__MODULE__{
-          test_event: %{
-            "requestUrl" => request_url,
-            "responseStatus" => response_status
-          },
-          service_error: nil
-        },
-        _expected_domain,
-        _url
-      )
-      when response_status not in [200, 202] and is_binary(request_url) do
-    proxying? = not String.starts_with?(request_url, PlausibleWeb.Endpoint.url())
-
-    if proxying? do
-      handled_error(@error_proxy_network_error)
-    else
-      handled_error(@error_plausible_network_error)
-    end
-  end
-
-  def interpret(
-        %__MODULE__{
-          tracker_is_in_html: false,
-          selected_installation_type: "manual",
-          plausible_is_on_window: plausible_is_on_window,
-          plausible_is_initialized: plausible_is_initialized,
-          service_error: nil
-        },
-        _expected_domain,
-        _url
-      )
-      when plausible_is_on_window != true and
-             plausible_is_initialized != true do
-    error_plausible_not_found("manual")
-    |> handled_error()
-  end
-
-  @error_csp_disallowed Error.new!(%{
-                          message:
-                            "We encountered an issue with your site's Content Security Policy (CSP)",
-                          recommendation:
-                            "Please add plausible.io domain specifically to the allowed list of domains in your site's CSP",
-                          url:
-                            "https://plausible.io/docs/troubleshoot-integration#does-your-site-use-a-content-security-policy-csp"
-                        })
-  def interpret(
-        %__MODULE__{
-          disallowed_by_csp: true,
-          service_error: nil
-        },
-        _expected_domain,
-        _url
-      ),
-      do: handled_error(@error_csp_disallowed)
-
-  @error_domain_not_found Error.new!(%{
-                            message: "We couldn't find your website at <%= @attempted_url %>",
-                            recommendation:
-                              "Please check that the domain you entered is correct and reachable publicly. If it's intentionally private, you'll need to verify that Plausible works manually",
-                            url: @verify_manually_url
-                          })
-
-  def interpret(%__MODULE__{service_error: %{code: code}}, expected_domain, url)
-      when code in [:domain_not_found, :invalid_url] do
-    attempted_url = if url, do: url, else: "https://#{expected_domain}"
-
-    @error_domain_not_found
-    |> handled_error(attempted_url: attempted_url)
-    |> struct!(data: %{offer_custom_url_input: true})
-  end
-
-  @error_browserless_network Error.new!(%{
-                               message:
-                                 "We couldn't verify your website at <%= @attempted_url %>",
-                               recommendation:
-                                 "Accessing the website resulted in a network error. Please verify your installation manually",
-                               url: @verify_manually_url
-                             })
-
-  def interpret(
-        %__MODULE__{service_error: %{code: :browserless_client_error, extra: "net::" <> _}},
-        _expected_domain,
-        url
-      )
-      when is_binary(url) do
-    attempted_url = shorten_url(url)
-
-    @error_browserless_network
-    |> handled_error(attempted_url: attempted_url)
-    |> struct!(data: %{offer_custom_url_input: true})
-  end
-
-  @error_browserless_temporary Error.new!(%{
-                                 message:
-                                   "Our verification tool encountered a temporary service error",
-                                 recommendation:
-                                   "Please try again in a few minutes or verify your installation manually",
-                                 url: @verify_manually_url
-                               })
-
-  def interpret(%__MODULE__{service_error: %{code: code}}, _expected_domain, _url)
-      when code in [:bad_browserless_response, :browserless_timeout, :internal_check_timeout] do
-    unhandled_error(@error_browserless_temporary, browserless_issue: true)
-  end
-
-  @error_unexpected_page_response Error.new!(%{
-                                    message:
-                                      "We couldn't verify your website at <%= @attempted_url %>",
-                                    recommendation:
-                                      "Accessing the website resulted in an unexpected status code <%= @page_response_status %>. Please check for anything that might be blocking us from reaching your site, like a firewall, authentication requirements, or CDN rules. If you'd prefer, you can skip this and verify your installation manually",
-                                    url: @verify_manually_url
-                                  })
-
-  def interpret(
-        %__MODULE__{
-          plausible_is_on_window: plausible_is_on_window,
-          plausible_is_initialized: plausible_is_initialized,
-          response_status: page_response_status
-        },
-        _expected_domain,
-        url
-      )
-      when is_binary(url) and not is_nil(page_response_status) and
-             (page_response_status < 200 or page_response_status >= 300) and
-             plausible_is_on_window != true and
-             plausible_is_initialized != true do
-    attempted_url = shorten_url(url)
-
-    @error_unexpected_page_response
-    |> handled_error(attempted_url: attempted_url, page_response_status: page_response_status)
-    |> struct!(data: %{offer_custom_url_input: true})
-  end
-
-  def interpret(
-        %__MODULE__{
-          selected_installation_type: selected_installation_type,
-          plausible_is_on_window: false,
-          service_error: nil
-        },
-        _expected_domain,
-        _url
-      ) do
-    error_plausible_not_found(selected_installation_type)
-    |> handled_error()
-  end
-
-  def interpret(%__MODULE__{} = diagnostics, _expected_domain, _url) do
-    error_plausible_not_found(diagnostics.selected_installation_type)
-    |> unhandled_error()
-  end
-
-  @message_plausible_not_found "We couldn't detect Plausible on your site"
-  @error_plausible_not_found_for_manual Error.new!(%{
-                                          message: @message_plausible_not_found,
-                                          recommendation:
-                                            "Please make sure you've copied the snippet to the head of your site, or verify your installation manually",
-                                          url: @verify_manually_url
-                                        })
-  @error_plausible_not_found_for_npm Error.new!(%{
-                                       message: @message_plausible_not_found,
-                                       recommendation:
-                                         "Please make sure you've initialized Plausible on your site, or verify your installation manually",
-                                       url: @verify_manually_url
-                                     })
-  @error_plausible_not_found_for_gtm Error.new!(%{
-                                       message: @message_plausible_not_found,
-                                       recommendation:
-                                         "Please make sure you've configured the GTM template correctly, or verify your installation manually",
-                                       url: @verify_manually_url
-                                     })
-  @error_plausible_not_found_for_wordpress Error.new!(%{
-                                             message: @message_plausible_not_found,
-                                             recommendation:
-                                               "Please make sure you've enabled the plugin, or verify your installation manually",
-                                             url: @verify_manually_url
-                                           })
-  defp error_plausible_not_found(selected_installation_type) do
-    case selected_installation_type do
-      "npm" -> @error_plausible_not_found_for_npm
-      "gtm" -> @error_plausible_not_found_for_gtm
-      "wordpress" -> @error_plausible_not_found_for_wordpress
-      _ -> @error_plausible_not_found_for_manual
-    end
-  end
-
-  @unexpected_domain_message "Plausible test event is not for this site"
-  @error_unexpected_domain_for_manual Error.new!(%{
-                                        message: @unexpected_domain_message,
-                                        recommendation:
-                                          "Please check that the snippet on your site matches the installation instructions exactly, or verify your installation manually",
-                                        url: @verify_manually_url
-                                      })
-
-  @error_unexpected_domain_for_npm Error.new!(%{
-                                     message: @unexpected_domain_message,
-                                     recommendation:
-                                       "Please check that you've initialized Plausible with the correct domain, or verify your installation manually",
-                                     url: @verify_manually_url
-                                   })
-
-  @error_unexpected_domain_for_gtm Error.new!(%{
-                                     message: @unexpected_domain_message,
-                                     recommendation:
-                                       "Please check that you've entered the ID in the GTM template correctly, or verify your installation manually",
-                                     url: @verify_manually_url
-                                   })
-
-  @error_unexpected_domain_for_wordpress Error.new!(%{
-                                           message: @unexpected_domain_message,
-                                           recommendation:
-                                             "Please check that you've installed the WordPress plugin correctly, or verify your installation manually",
-                                           url: @verify_manually_url
-                                         })
-  defp error_unexpected_domain(selected_installation_type) do
-    case selected_installation_type do
-      "npm" -> @error_unexpected_domain_for_npm
-      "gtm" -> @error_unexpected_domain_for_gtm
-      "wordpress" -> @error_unexpected_domain_for_wordpress
-      _ -> @error_unexpected_domain_for_manual
-    end
-  end
-
-  defp shorten_url(url) do
-    String.split(url, "?") |> List.first()
-  end
-
-  defp success() do
-    %Result{ok?: true}
-  end
-
-  defp handled_error(%Error{} = error, assigns \\ []) do
-    message = EEx.eval_string(error.message, assigns: assigns)
-    recommendation = EEx.eval_string(error.recommendation, assigns: assigns)
-
-    %Result{
-      ok?: false,
-      errors: [message],
-      recommendations: [%{text: recommendation, url: error.url}]
-    }
-  end
-
-  defp unhandled_error(%Error{} = error, opts \\ []) do
-    browserless_issue = Keyword.get(opts, :browserless_issue, false)
-
-    %Result{
-      ok?: false,
-      data: %{unhandled: true, browserless_issue: browserless_issue},
-      errors: [error.message],
-      recommendations: [%{text: error.recommendation, url: error.url}]
-    }
-  end
-end

extra/lib/plausible/plugins/api/funnels.ex

@@ -1,61 +0,0 @@
-defmodule Plausible.Plugins.API.Funnels do
-  @moduledoc """
-  Plugins API context module for Funnels.
-  All high level Funnel operations should be implemented here.
-  """
-  use Plausible
-
-  import Plausible.Pagination
-
-  alias Plausible.Repo
-  alias PlausibleWeb.Plugins.API.Schemas.Funnel.CreateRequest
-
-  @type create_request() :: CreateRequest.t()
-
-  @spec create(
-          Plausible.Site.t(),
-          create_request()
-        ) ::
-          {:ok, Plausible.Funnel.t()}
-          | {:error, Ecto.Changeset.t()}
-          | {:error, :upgrade_required}
-  def create(site, create_request) do
-    Repo.transaction(fn ->
-      with {:ok, goals} <- Plausible.Plugins.API.Goals.create(site, create_request.funnel.steps),
-           {:ok, funnel} <- get_or_create(site, create_request.funnel.name, goals) do
-        funnel
-      else
-        {:error, error} ->
-          Repo.rollback(error)
-      end
-    end)
-  end
-
-  defp get_or_create(site, name, goals) do
-    case get(site, name) do
-      %Plausible.Funnel{} = funnel ->
-        {:ok, funnel}
-
-      nil ->
-        case Plausible.Funnels.create(site, name, goals) do
-          {:ok, funnel} ->
-            # reload result with steps included
-            {:ok, get(site, funnel.id)}
-
-          error ->
-            error
-        end
-    end
-  end
-
-  @spec get_funnels(Plausible.Site.t(), map()) :: {:ok, Paginator.Page.t()}
-  def get_funnels(site, params) do
-    query = Plausible.Funnels.with_goals_query(site)
-    {:ok, paginate(query, params, cursor_fields: [{:id, :desc}])}
-  end
-
-  @spec get(Plausible.Site.t(), pos_integer() | String.t()) :: nil | Plausible.Funnel.t()
-  def get(site, by) when is_integer(by) or is_binary(by) do
-    Plausible.Funnels.get(site, by)
-  end
-end

extra/lib/plausible/site/tracker_script_id_cache.ex

@@ -1,50 +0,0 @@
-defmodule Plausible.Site.TrackerScriptIdCache do
-  @moduledoc """
-  Cache for tracker script IDs to avoid excessive database lookups when the
-  script API endpoint is bombarded with random IDs.
-  """
-  alias Plausible.Site.TrackerScriptConfiguration
-  alias PlausibleWeb.Tracker
-
-  import Ecto.Query
-  use Plausible
-  use Plausible.Cache
-
-  @cache_name :tracker_script_id_cache
-
-  @impl true
-  def name(), do: @cache_name
-
-  @impl true
-  def child_id(), do: :cache_tracker_script_id
-
-  @impl true
-  def count_all() do
-    Plausible.Repo.aggregate(TrackerScriptConfiguration, :count)
-  end
-
-  @impl true
-  def base_db_query(), do: Tracker.get_tracker_script_configuration_base_query()
-
-  @impl true
-  def get_from_source(id) do
-    case Tracker.get_tracker_script_configuration_by_id(id) do
-      %TrackerScriptConfiguration{site: %{domain: _domain}} ->
-        true
-
-      _ ->
-        nil
-    end
-  end
-
-  @impl true
-  def unwrap_cache_keys(items) do
-    Enum.reduce(items, [], fn
-      tracker_script_configuration, acc ->
-        [
-          {tracker_script_configuration.id, true}
-          | acc
-        ]
-    end)
-  end
-end

extra/lib/plausible/stats/exploration.ex

@@ -1,613 +0,0 @@
-defmodule Plausible.Stats.Exploration do
-  @moduledoc """
-  Query logic for user journey exploration.
-  """
-
-  import Ecto.Query
-  import Plausible.Stats.SQL.Fragments
-  import Plausible.Stats.Util, only: [percentage: 2]
-
-  alias Plausible.ClickhouseRepo
-  alias Plausible.Stats.Base
-  alias Plausible.Stats.Exploration.Journey
-  alias Plausible.Stats.Filters
-  alias Plausible.Stats.Query
-
-  @type journey() :: [Journey.Step.t()]
-  @type direction() :: :forward | :backward
-
-  defguard is_direction(value) when value in [:forward, :backward]
-
-  @type next_step() :: %{
-          step: Journey.Step.t(),
-          visitors: pos_integer()
-        }
-
-  @type funnel_step() :: %{
-          step: Journey.Step.t(),
-          visitors: non_neg_integer(),
-          dropoff: non_neg_integer(),
-          dropoff_percentage: String.t(),
-          conversion_rate: String.t(),
-          conversion_rate_step: String.t()
-        }
-
-  @max_steps 20
-  @max_candidates 50
-
-  @next_steps_defaults [
-    search_term: "",
-    direction: :forward,
-    max_candidates: 10,
-    include_wildcard?: true
-  ]
-
-  @spec max_steps() :: pos_integer()
-  def max_steps, do: @max_steps
-
-  @spec next_steps(Plausible.Site.t(), Query.t(), journey(), keyword()) ::
-          {:ok, [next_step()]} | {:error, :journey_too_long}
-  def next_steps(site, query, journey, opts \\ [])
-
-  def next_steps(_site, _query, journey, _opts) when length(journey) >= @max_steps do
-    {:error, :journey_too_long}
-  end
-
-  def next_steps(site, query, journey, opts) do
-    opts = Keyword.merge(@next_steps_defaults, opts)
-    direction = Keyword.fetch!(opts, :direction)
-    search_term = Keyword.fetch!(opts, :search_term)
-    max_candidates = min(Keyword.fetch!(opts, :max_candidates), @max_candidates)
-    include_wilcard? = Keyword.fetch!(opts, :include_wildcard?)
-
-    goals =
-      site
-      |> Plausible.Goals.for_site(include_goals_with_custom_props?: false)
-      |> filter_eligible_goals()
-
-    query
-    |> Base.base_event_query()
-    |> next_steps_query(journey, search_term, direction, max_candidates, include_wilcard?, goals)
-    # We pass the query struct to record query metadata for
-    # the CH debug console.
-    |> ClickhouseRepo.all(query: query)
-    |> then(&{:ok, &1})
-  end
-
-  @spec journey_funnel(Query.t(), journey(), direction()) ::
-          {:ok, [funnel_step()]} | {:error, :empty_journey | :journey_too_long}
-  def journey_funnel(query, journey, direction \\ :forward)
-
-  def journey_funnel(_query, [], _direction), do: {:error, :empty_journey}
-
-  def journey_funnel(_query, journey, _direction) when length(journey) > @max_steps do
-    {:error, :journey_too_long}
-  end
-
-  def journey_funnel(query, journey, direction) when is_direction(direction) do
-    query
-    |> Base.base_event_query()
-    |> journey_funnel_query(journey, direction)
-    # We pass the query struct to record query metadata for
-    # the CH debug console.
-    |> ClickhouseRepo.all(query: query)
-    |> to_funnel(journey)
-    |> then(&{:ok, &1})
-  end
-
-  defp filter_eligible_goals(goals) do
-    Enum.reject(goals, fn g ->
-      Plausible.Goal.Revenue.revenue?(g) or g.scroll_threshold > -1 or
-        Plausible.Goal.has_custom_props?(g)
-    end)
-  end
-
-  defp next_steps_query(
-         query,
-         steps,
-         search_term,
-         direction,
-         max_candidates,
-         include_wildcard?,
-         goals
-       )
-       when is_direction(direction) do
-    next_step_idx = length(steps) + 1
-    q_steps = steps_query(query, next_step_idx, direction)
-
-    next_name = :"name#{next_step_idx}"
-    next_pathname = :"pathname#{next_step_idx}"
-
-    q_matches =
-      from(s in subquery(q_steps),
-        select: %{
-          user_id: s.user_id,
-          name: selected_as(field(s, ^next_name), :name),
-          pathname: selected_as(field(s, ^next_pathname), :pathname),
-          _sample_factor: fragment("any(?)", s._sample_factor)
-        },
-        group_by: [selected_as(:name), selected_as(:pathname), s.user_id]
-      )
-
-    q_matches =
-      steps
-      |> Enum.with_index()
-      |> Enum.reduce(q_matches, fn {step, idx}, q ->
-        step_condition = step_condition(step, idx + 1)
-
-        from(s in q, where: ^step_condition)
-      end)
-      |> maybe_exclude_step_matches(List.last(steps))
-
-    # Fan out each q_combined row into up to two output rows (exact + wildcard)
-    # using ARRAY JOIN over a small boolean array.
-    #
-    # For each row we build [false, true] and filter it down to just [false]
-    # when the wildcard row should be suppressed (non-pageview, only one distinct
-    # subpath, or same visitor count as exact). ARRAY JOIN then emits one or more
-    # rows per group. The joined boolean `is_wildcard` selects which values to
-    # use for visitors / includes_subpaths / subpaths_count.
-    q_wildcard_combined_matches =
-      q_matches
-      |> combined_wildcard_query(include_wildcard?)
-      |> combined_wildcard_matches_query()
-
-    q_all_combined_matches =
-      if q_goal_matches = goals_query(q_matches, goals) do
-        q_wildcard_combined_matches
-        |> exclude_goal_matches(goals)
-        |> union_all(^q_goal_matches)
-      else
-        q_wildcard_combined_matches
-      end
-
-    from(m in subquery(q_all_combined_matches),
-      select: %{
-        step: %Journey.Step{
-          label:
-            selected_as(
-              fragment("if(? != '', ?, ?)", m.name, m.label, ^Journey.Step.journey_end_label()),
-              :label
-            ),
-          name: fragment("if(? != '', ?, ?)", m.name, m.name, ^Journey.Step.journey_end_event()),
-          pathname: m.pathname,
-          includes_subpaths: m.includes_subpaths,
-          subpaths_count: m.subpaths_count,
-          is_goal: m.is_goal
-        },
-        visitors: m.visitors
-      },
-      order_by: [
-        desc: m.visitors,
-        asc: m.pathname,
-        asc: m.name
-      ],
-      limit: ^max_candidates
-    )
-    |> maybe_search(search_term)
-  end
-
-  defp goals_query(_, []), do: nil
-
-  defp goals_query(q_matches, goals) do
-    values =
-      Enum.map(goals, fn g ->
-        pathname = g.page_path || ""
-
-        regex_pathname =
-          if String.contains?(pathname, "*") do
-            Filters.Utils.page_regex(pathname)
-          else
-            ""
-          end
-
-        %{
-          label: g.display_name,
-          name: g.event_name || "pageview",
-          pathname: pathname,
-          regex_pathname: regex_pathname
-        }
-      end)
-
-    types = %{label: :string, name: :string, pathname: :string, regex_pathname: :string}
-
-    query =
-      from(m in subquery(q_matches),
-        inner_join: g in values(values, types),
-        on:
-          g.name == m.name and
-            (g.name != "pageview" or
-               (g.name == "pageview" and
-                  fragment(
-                    "if(? != '', match(?, ?), ? = ?)",
-                    g.regex_pathname,
-                    m.pathname,
-                    g.regex_pathname,
-                    m.pathname,
-                    g.pathname
-                  ))),
-        select: %{
-          label: selected_as(g.label, :label),
-          name: selected_as(g.name, :name),
-          pathname: selected_as(g.pathname, :pathname),
-          visitors: scale_sample(fragment("uniq(?)", m.user_id)),
-          includes_subpaths: fragment("CAST(?, 'Bool')", false),
-          subpaths_count: 0,
-          is_goal: fragment("CAST(?, 'Bool')", true)
-        },
-        group_by: [selected_as(:label), selected_as(:name), selected_as(:pathname)]
-      )
-
-    from(m in subquery(query),
-      where: m.visitors > 0
-    )
-  end
-
-  defp maybe_exclude_step_matches(query, %{includes_subpaths: true} = step) do
-    pattern = wildcard_pattern(step.pathname)
-
-    from m in query,
-      where:
-        selected_as(:name) != ^step.name or
-          not fragment("match(?, ?)", selected_as(:pathname), ^pattern)
-  end
-
-  defp maybe_exclude_step_matches(query, %{is_goal: true, name: "pageview"} = step) do
-    if String.contains?(step.pathname, "*") do
-      pattern = Filters.Utils.page_regex(step.pathname)
-
-      from m in query,
-        where:
-          selected_as(:name) != ^step.name or
-            not fragment("match(?, ?)", selected_as(:pathname), ^pattern)
-    else
-      query
-    end
-  end
-
-  defp maybe_exclude_step_matches(query, _), do: query
-
-  defp exclude_goal_matches(query, goals) do
-    to_exclude =
-      goals
-      |> Enum.filter(fn g -> is_nil(g.page_path) or not String.contains?(g.page_path, "*") end)
-      |> Enum.map(fn g ->
-        %{
-          name: g.event_name || "pageview",
-          pathname: g.page_path || ""
-        }
-      end)
-
-    if to_exclude != [] do
-      types = %{name: :string, pathname: :string}
-
-      from m in subquery(query),
-        left_join: g in values(to_exclude, types),
-        on: g.name == m.name and g.pathname == m.pathname,
-        where: g.name == "" or m.includes_subpaths
-    else
-      query
-    end
-  end
-
-  # Expand each (name, pathname, user_id) row into all prefix paths via
-  # ARRAY JOIN, then aggregate once to get both exact and wildcard visitor
-  # counts in a single scan of events_v2.
-  #
-  # The arrayFold expansion includes the original pathname as the last
-  # element, so uniqIf(user_id, original_pathname = prefix_pathname) gives the
-  # exact-match count for free, alongside the wildcard uniq(user_id) and the
-  # uniq(original_pathname) subpath count — all in one GROUP BY.
-  #
-  # Non-pageview events are included in the expansion but produce only a
-  # single prefix (their exact pathname), so they naturally get
-  # subpaths_count = 1 and are only emitted as exact rows.
-  @wildcard_array_join """
-  if(? = 'pageview', arrayFold(
-    acc, x -> arrayPushBack(acc, concat(acc[-1], '/', x)), 
-    arraySlice(splitByChar('/', ?) AS split_pathname, 2), 
-    arraySlice(split_pathname, 1, 1)), [?])
-  """
-
-  defp combined_wildcard_query(q_matches, true = _include_wildcard?) do
-    from(em in subquery(q_matches),
-      join: pname in fragment(@wildcard_array_join, em.name, em.pathname, em.pathname),
-      on: true,
-      hints: "ARRAY",
-      where: em.name != "pageview" or selected_as(:pathname) != "",
-      select: %{
-        name: em.name,
-        pathname: selected_as(fragment("?", pname), :pathname),
-        exact_visitors:
-          scale_sample(fragment("uniqIf(?, ? = ?)", em.user_id, em.pathname, pname)),
-        wildcard_visitors:
-          selected_as(scale_sample(fragment("uniq(?)", em.user_id)), :wildcard_visitors),
-        subpaths_count: scale_sample(fragment("uniq(?)", em.pathname))
-      },
-      group_by: [em.name, selected_as(:pathname)]
-    )
-  end
-
-  defp combined_wildcard_query(q_matches, false = _include_wildcard?) do
-    from(em in subquery(q_matches),
-      where: em.name != "pageview" or selected_as(:pathname) != "",
-      select: %{
-        name: em.name,
-        pathname: selected_as(em.pathname, :pathname),
-        exact_visitors:
-          selected_as(scale_sample(fragment("uniq(?)", em.user_id)), :exact_visitors),
-        wildcard_visitors: selected_as(:exact_visitors),
-        subpaths_count: 1
-      },
-      group_by: [em.name, selected_as(:pathname)]
-    )
-  end
-
-  defp combined_wildcard_matches_query(q_wildcard_combined) do
-    from(m in subquery(q_wildcard_combined),
-      join:
-        is_wildcard in fragment(
-          """
-          arrayFilter(
-            x -> x = false OR (? = 'pageview' AND ? != '/' AND ? > 1 AND ? != ?),
-            [false, true]
-          )
-          """,
-          m.name,
-          m.pathname,
-          m.subpaths_count,
-          m.wildcard_visitors,
-          m.exact_visitors
-        ),
-      on: true,
-      hints: "ARRAY",
-      where: selected_as(:visitors) > 0,
-      select: %{
-        label:
-          selected_as(
-            fragment(
-              "if(? != 'pageview', ?, ?)",
-              m.name,
-              m.name,
-              m.pathname
-            ),
-            :label
-          ),
-        name: selected_as(m.name, :name),
-        pathname: selected_as(m.pathname, :pathname),
-        visitors:
-          selected_as(
-            fragment("if(?, ?, ?)", is_wildcard, m.wildcard_visitors, m.exact_visitors),
-            :visitors
-          ),
-        includes_subpaths:
-          selected_as(fragment("CAST(?, 'Bool')", is_wildcard), :includes_subpaths),
-        subpaths_count: fragment("if(?, ?, 0)", is_wildcard, m.subpaths_count),
-        is_goal: fragment("CAST(?, 'Bool')", false)
-      }
-    )
-  end
-
-  defp journey_funnel_query(query, steps, direction) do
-    q_steps = steps_query(query, length(steps), direction)
-
-    q_funnel = from(s in subquery(q_steps), select: %{})
-
-    steps
-    |> Enum.with_index()
-    |> Enum.reduce(q_funnel, fn
-      {step, 0}, q ->
-        step_condition = step_condition(step, 1)
-
-        from(e in q,
-          select_merge: %{
-            1 => scale_sample(fragment("uniq(?)", e.user_id))
-          },
-          where: ^step_condition
-        )
-
-      {_step, idx}, q ->
-        current_steps = Enum.take(steps, idx + 1)
-
-        step_conditions =
-          current_steps
-          |> Enum.with_index()
-          |> Enum.reduce(dynamic(true), fn {step, idx}, acc ->
-            step_condition = step_condition(step, idx + 1)
-            dynamic([q], fragment("? and ?", ^acc, ^step_condition))
-          end)
-
-        step_count =
-          dynamic(
-            [e],
-            scale_sample(
-              fragment(
-                "uniqIf(?, ?)",
-                e.user_id,
-                ^step_conditions
-              )
-            )
-          )
-
-        from(e in q, select_merge: ^%{(idx + 1) => step_count})
-    end)
-  end
-
-  defp steps_query(query, steps, direction) when is_integer(steps) do
-    q_pairs =
-      from(e in query,
-        windows: [
-          session_window: [
-            partition_by: e.user_id,
-            order_by: [asc: e.timestamp]
-          ]
-        ],
-        select: %{
-          site_id: e.site_id,
-          user_id: e.user_id,
-          _sample_factor: e._sample_factor,
-          row_number: row_number() |> over(:session_window),
-          name: e.name,
-          pathname: fragment("if(? = 'pageview', ?, '')", e.name, e.pathname),
-          timestamp: e.timestamp
-        },
-        where: e.name != "engagement" and e.revenue_reporting_currency == ""
-      )
-      |> select_previous(direction)
-
-    q_steps =
-      from(e in subquery(q_pairs),
-        windows: [
-          step_window: [partition_by: e.user_id, order_by: [asc: e.timestamp, asc: e.row_number]]
-        ],
-        select: %{
-          user_id: e.user_id,
-          _sample_factor: e._sample_factor,
-          name1: e.name,
-          pathname1: e.pathname
-        },
-        where: e.prev_name != e.name or e.prev_pathname != e.pathname
-      )
-
-    if steps > 1 do
-      Enum.reduce(1..(steps - 1), q_steps, fn idx, q ->
-        select_next(q, idx, direction)
-      end)
-    else
-      q_steps
-    end
-  end
-
-  defp select_previous(query, :forward) do
-    from(e in query,
-      select_merge: %{
-        prev_pathname:
-          lag(fragment("if(? = 'pageview', ?, '')", e.name, e.pathname)) |> over(:session_window),
-        prev_name: lag(e.name) |> over(:session_window)
-      }
-    )
-  end
-
-  defp select_previous(query, :backward) do
-    from(e in query,
-      select_merge: %{
-        prev_pathname:
-          lead(fragment("if(? = 'pageview', ?, '')", e.name, e.pathname)) |> over(:session_window),
-        prev_name: lead(e.name) |> over(:session_window)
-      }
-    )
-  end
-
-  defp select_next(query, idx, :forward) do
-    from(e in query,
-      select_merge: %{
-        ^:"name#{idx + 1}" => lead(e.name, ^idx) |> over(:step_window),
-        ^:"pathname#{idx + 1}" => lead(e.pathname, ^idx) |> over(:step_window)
-      }
-    )
-  end
-
-  defp select_next(query, idx, :backward) do
-    from(e in query,
-      select_merge: %{
-        ^:"name#{idx + 1}" => lag(e.name, ^idx) |> over(:step_window),
-        ^:"pathname#{idx + 1}" => lag(e.pathname, ^idx) |> over(:step_window)
-      }
-    )
-  end
-
-  defp step_condition(step, count) when count <= @max_steps do
-    cond do
-      step.includes_subpaths ->
-        pattern = wildcard_pattern(step.pathname)
-
-        dynamic(
-          [s],
-          field(s, ^:"name#{count}") == ^step.name and
-            fragment("match(?, ?)", field(s, ^:"pathname#{count}"), ^pattern)
-        )
-
-      step.is_goal and step.name == "pageview" and String.contains?(step.pathname, "*") ->
-        pattern = Filters.Utils.page_regex(step.pathname)
-
-        dynamic(
-          [s],
-          field(s, ^:"name#{count}") == ^step.name and
-            fragment("match(?, ?)", field(s, ^:"pathname#{count}"), ^pattern)
-        )
-
-      step.name == Journey.Step.journey_end_event() ->
-        dynamic(
-          [s],
-          field(s, ^:"name#{count}") == ""
-        )
-
-      true ->
-        dynamic(
-          [s],
-          field(s, ^:"name#{count}") == ^step.name and
-            field(s, ^:"pathname#{count}") == ^step.pathname
-        )
-    end
-  end
-
-  defp wildcard_pattern(pathname) when is_binary(pathname) do
-    escaped = Regex.escape(pathname)
-
-    "^#{escaped}(/.*)?$"
-  end
-
-  defp maybe_search(query, search_term) do
-    case String.trim(search_term) do
-      term when byte_size(term) > 2 ->
-        from(s in query,
-          where:
-            ilike(selected_as(:label), ^"%#{term}%") or
-              ilike(s.pathname, ^"%#{term}%") or
-              (s.name != "pageview" and ilike(s.name, ^"%#{term}%"))
-        )
-
-      _ ->
-        query
-    end
-  end
-
-  defp to_funnel([result], journey) do
-    journey
-    |> Enum.with_index()
-    |> Enum.reduce(%{funnel: [], visitors_at_previous: nil, total_visitors: nil}, fn {step, idx},
-                                                                                     acc ->
-      step = Journey.Step.from(step)
-      current_visitors = Map.get(result, idx + 1, 0)
-      total_visitors = acc.total_visitors || current_visitors
-
-      dropoff =
-        if acc.visitors_at_previous, do: acc.visitors_at_previous - current_visitors, else: 0
-
-      dropoff_percentage = percentage(dropoff, acc.visitors_at_previous)
-      conversion_rate = percentage(current_visitors, total_visitors)
-      conversion_rate_step = percentage(current_visitors, acc.visitors_at_previous)
-
-      funnel = [
-        %{
-          step: step,
-          visitors: current_visitors,
-          dropoff: dropoff,
-          dropoff_percentage: dropoff_percentage,
-          conversion_rate: conversion_rate,
-          conversion_rate_step: conversion_rate_step
-        }
-        | acc.funnel
-      ]
-
-      %{
-        acc
-        | funnel: funnel,
-          visitors_at_previous: current_visitors,
-          total_visitors: total_visitors
-      }
-    end)
-    |> Map.fetch!(:funnel)
-    |> Enum.reverse()
-  end
-end

extra/lib/plausible/stats/funnel.ex

@@ -1,171 +0,0 @@
-defmodule Plausible.Stats.Funnel do
-  @moduledoc """
-  Module responsible for funnel evaluation, i.e. building and executing
-  ClickHouse funnel query based on `Plausible.Funnel` definition.
-  """
-
-  @funnel_window_duration 86_400
-
-  alias Plausible.Funnel
-  alias Plausible.Funnels
-
-  import Ecto.Query
-  import Plausible.Stats.SQL.Fragments
-  import Plausible.Stats.Util, only: [percentage: 2]
-
-  alias Plausible.ClickhouseRepo
-  alias Plausible.Stats.{Base, Query}
-
-  @spec funnel(Plausible.Site.t(), Plausible.Stats.Query.t(), Funnel.t() | pos_integer()) ::
-          {:ok, map()} | {:error, :funnel_not_found}
-  def funnel(site, query, funnel_id) when is_integer(funnel_id) do
-    case Funnels.get(site.id, funnel_id) do
-      %Funnel{} = funnel ->
-        funnel(site, query, funnel)
-
-      nil ->
-        {:error, :funnel_not_found}
-    end
-  end
-
-  def funnel(_site, query, %Funnel{} = funnel) do
-    goals = Enum.map(funnel.steps, & &1.goal)
-
-    funnel_data =
-      query
-      |> Query.set(preloaded_goals: %{all: [], matching_toplevel_filters: goals})
-      |> Base.base_event_query()
-      |> funnel_query(funnel)
-      # We pass the query struct to record query metadata for
-      # the CH debug console.
-      |> ClickhouseRepo.all(query: query)
-
-    # Funnel definition steps are 1-indexed, if there's index 0 in the resulting query,
-    # it signifies the number of visitors that haven't entered the funnel.
-    not_entering_visitors =
-      case funnel_data do
-        [{0, count} | _] -> count
-        _ -> 0
-      end
-
-    all_visitors = Enum.reduce(funnel_data, 0, fn {_, n}, acc -> acc + n end)
-    steps = backfill_steps(funnel_data, funnel)
-
-    visitors_at_first_step = List.first(steps).visitors
-
-    {:ok,
-     %{
-       name: funnel.name,
-       steps: steps,
-       all_visitors: all_visitors,
-       entering_visitors: visitors_at_first_step,
-       entering_visitors_percentage: percentage(visitors_at_first_step, all_visitors),
-       never_entering_visitors: all_visitors - visitors_at_first_step,
-       never_entering_visitors_percentage: percentage(not_entering_visitors, all_visitors)
-     }}
-  end
-
-  defp funnel_query(query, funnel_definition) do
-    q_events =
-      from(e in query,
-        select: %{user_id: e.user_id, _sample_factor: fragment("any(_sample_factor)")},
-        where: e.site_id == ^funnel_definition.site_id,
-        group_by: e.user_id,
-        order_by: [desc: fragment("step")]
-      )
-      |> select_funnel(funnel_definition)
-
-    from(f in subquery(q_events),
-      select: {f.step, total()},
-      group_by: f.step
-    )
-  end
-
-  defp select_funnel(db_query, funnel_definition) do
-    window_funnel_steps =
-      Enum.reduce(funnel_definition.steps, nil, fn step, acc ->
-        goal_condition = Plausible.Stats.Goals.goal_condition(step.goal)
-
-        if acc do
-          dynamic([q], fragment("?, ?", ^acc, ^goal_condition))
-        else
-          dynamic([q], fragment("?", ^goal_condition))
-        end
-      end)
-
-    dynamic_window_funnel =
-      if funnel_definition.strict_order do
-        dynamic(
-          [q],
-          fragment(
-            "windowFunnel(?, 'strict_order')(timestamp, ?)",
-            @funnel_window_duration,
-            ^window_funnel_steps
-          )
-        )
-      else
-        dynamic(
-          [q],
-          fragment("windowFunnel(?)(timestamp, ?)", @funnel_window_duration, ^window_funnel_steps)
-        )
-      end
-
-    from(q in db_query,
-      select_merge:
-        ^%{
-          step: dynamic_window_funnel
-        }
-    )
-  end
-
-  defp backfill_steps(funnel_result, funnel) do
-    # Directly from ClickHouse we only get {step_idx(), visitor_count()} tuples.
-    # but no totals including previous steps are aggregated.
-    # Hence we need to perform the appropriate backfill
-    # and also calculate dropoff and conversion rate for each step.
-    # In case ClickHouse returns 0-index funnel result, we're going to ignore it
-    # anyway, since we fold over steps as per definition, that are always
-    # indexed starting from 1.
-    funnel_result = Enum.into(funnel_result, %{})
-    max_step = Enum.max_by(funnel.steps, & &1.step_order).step_order
-
-    funnel
-    |> Map.fetch!(:steps)
-    |> Enum.reduce({nil, nil, []}, fn step, {total_visitors, visitors_at_previous, acc} ->
-      # first step contains the total number of all visitors qualifying for the funnel,
-      # with each subsequent step needing to accumulate sum of the previous one(s)
-      visitors_at_step =
-        step.step_order..max_step
-        |> Enum.map(&Map.get(funnel_result, &1, 0))
-        |> Enum.sum()
-
-      # accumulate current_visitors for the next iteration
-      current_visitors = visitors_at_step
-
-      # First step contains the total number of visitors that we base percentage dropoff on
-      total_visitors =
-        total_visitors ||
-          current_visitors
-
-      # Dropoff is 0 for the first step, otherwise we subtract current from previous
-      dropoff = if visitors_at_previous, do: visitors_at_previous - current_visitors, else: 0
-
-      dropoff_percentage = percentage(dropoff, visitors_at_previous)
-      conversion_rate = percentage(current_visitors, total_visitors)
-      conversion_rate_step = percentage(current_visitors, visitors_at_previous)
-
-      step = %{
-        dropoff: dropoff,
-        dropoff_percentage: dropoff_percentage,
-        conversion_rate: conversion_rate,
-        conversion_rate_step: conversion_rate_step,
-        visitors: visitors_at_step,
-        label: to_string(step.goal)
-      }
-
-      {total_visitors, current_visitors, [step | acc]}
-    end)
-    |> elem(2)
-    |> Enum.reverse()
-  end
-end

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

@@ -1,94 +0,0 @@
-defmodule Plausible.Stats.Goal.Revenue do
-  @moduledoc """
-  Revenue specific functions for the stats scope
-  """
-
-  @revenue_metrics [:average_revenue, :total_revenue]
-
-  def revenue_metrics() do
-    @revenue_metrics
-  end
-
-  @doc """
-  Preloads revenue currencies for a query. Used when parsing the query.
-
-  Returns tuple containing revenue warning (if set, no revenue metrics should be calculated) and
-  revenue currencies map.
-
-  Assumptions and business logic:
-  1. Goals are already filtered according to query filters and dimensions
-  2. If there's a single currency involved, return map containing the default
-  3. If there's a breakdown by event:goal we return all the relevant currencies as a map
-  4. If filtering by multiple different currencies without event:goal breakdown empty map is returned
-  5. If user has no access or preloading is not needed, empty map is returned
-
-  The resulting data structure is attached to a `Query` and used below in `format_revenue_metric/3`.
-  """
-  def preload(site, preloaded_goals, metrics, dimensions) do
-    cond do
-      not requested?(metrics) -> {nil, %{}}
-      not available?(site) -> {:revenue_goals_unavailable, %{}}
-      true -> preload(preloaded_goals.matching_toplevel_filters, dimensions)
-    end
-  end
-
-  defp preload(goals, dimensions) do
-    goal_currency_map =
-      goals
-      |> Map.new(fn goal -> {Plausible.Goal.display_name(goal), goal.currency} end)
-      |> Map.reject(fn {_goal, currency} -> is_nil(currency) end)
-
-    currencies = goal_currency_map |> Map.values() |> Enum.uniq()
-    goal_dimension? = "event:goal" in dimensions
-
-    case {currencies, goal_dimension?} do
-      {[currency], false} -> {nil, %{default: currency}}
-      {[], _} -> {:no_revenue_goals_matching, %{}}
-      {_, true} -> {nil, goal_currency_map}
-      _ -> {:no_single_revenue_currency, %{}}
-    end
-  end
-
-  def format_revenue_metric(_, query, _) when not is_nil(query.revenue_warning), do: nil
-
-  def format_revenue_metric(value, query, dimension_values) do
-    currency =
-      query.revenue_currencies[:default] ||
-        get_goal_dimension_revenue_currency(query, dimension_values)
-
-    format_revenue_metric(value, currency)
-  end
-
-  def format_revenue_metric(value, currency) do
-    if currency do
-      money = Money.new!(value || 0, currency)
-
-      %{
-        short: Money.to_string!(money, format: :short, fractional_digits: 1),
-        long: Money.to_string!(money),
-        value: Decimal.to_float(money.amount),
-        currency: currency
-      }
-    else
-      value
-    end
-  end
-
-  def available?(site) do
-    site = Plausible.Repo.preload(site, :team)
-    Plausible.Billing.Feature.RevenueGoals.check_availability(site.team) == :ok
-  end
-
-  # :NOTE: Legacy queries don't have metrics associated with them so work around the issue by assuming
-  #   revenue metric was requested.
-  def requested?([]), do: true
-  def requested?(metrics), do: Enum.any?(metrics, &(&1 in @revenue_metrics))
-
-  defp get_goal_dimension_revenue_currency(query, dimension_values) do
-    Enum.zip(query.dimensions, dimension_values)
-    |> Enum.find_value(fn
-      {"event:goal", goal_label} -> Map.get(query.revenue_currencies, goal_label)
-      _ -> nil
-    end)
-  end
-end

extra/lib/plausible/stats/journey/step.ex

@@ -1,53 +0,0 @@
-defmodule Plausible.Stats.Exploration.Journey.Step do
-  @moduledoc false
-
-  @type t() :: %__MODULE__{}
-
-  @derive {Jason.Encoder,
-           only: [:name, :pathname, :label, :includes_subpaths, :subpaths_count, :is_goal]}
-  defstruct name: nil,
-            pathname: "",
-            label: nil,
-            includes_subpaths: false,
-            subpaths_count: 0,
-            is_goal: false
-
-  @journey_end_event "__journey_end__"
-  @journey_end_label "No further action"
-
-  @spec journey_end_event() :: String.t()
-  def journey_end_event, do: @journey_end_event
-
-  @spec journey_end_label() :: String.t()
-  def journey_end_label, do: @journey_end_label
-
-  @spec from(map()) :: t()
-  def from(step) do
-    new(step.name, step.pathname, step.includes_subpaths, step.subpaths_count, step.is_goal)
-  end
-
-  @spec new(String.t(), String.t(), boolean(), non_neg_integer(), boolean()) :: t()
-  def new(name, pathname, includes_subpaths \\ false, subpaths_count \\ 0, is_goal \\ false)
-      when is_boolean(includes_subpaths) and is_integer(subpaths_count) do
-    label =
-      cond do
-        name == @journey_end_event ->
-          @journey_end_label
-
-        name != "pageview" ->
-          name
-
-        true ->
-          pathname
-      end
-
-    %__MODULE__{
-      label: label,
-      name: name,
-      pathname: pathname,
-      includes_subpaths: includes_subpaths,
-      subpaths_count: subpaths_count,
-      is_goal: is_goal
-    }
-  end
-end

extra/lib/plausible/stats/sampling.ex

@@ -1,105 +0,0 @@
-defmodule Plausible.Stats.Sampling do
-  @moduledoc """
-  Sampling related functions
-  """
-  @default_sample_threshold 10_000_000
-
-  import Ecto.Query
-
-  alias Plausible.Stats.{Query, SamplingCache}
-
-  def default_sample_threshold(), do: @default_sample_threshold
-
-  @spec add_query_hint(Ecto.Query.t(), Plausible.Stats.Query.t()) :: Ecto.Query.t()
-  def add_query_hint(%Ecto.Query{} = db_query, %Plausible.Stats.Query{} = query) do
-    case query.sample_threshold do
-      :no_sampling ->
-        db_query
-
-      nil ->
-        db_query
-
-      threshold ->
-        add_query_hint(db_query, threshold)
-    end
-  end
-
-  @spec add_query_hint(Ecto.Query.t(), pos_integer() | float()) :: Ecto.Query.t()
-  def add_query_hint(%Ecto.Query{} = query, threshold) when is_number(threshold) do
-    from(x in query, hints: unsafe_fragment(^"SAMPLE #{threshold}"))
-  end
-
-  @spec add_query_hint(Ecto.Query.t()) :: Ecto.Query.t()
-  def add_query_hint(%Ecto.Query{} = query) do
-    add_query_hint(query, @default_sample_threshold)
-  end
-
-  @spec put_threshold(Plausible.Stats.Query.t(), Plausible.Site.t(), map()) ::
-          Plausible.Stats.Query.t()
-  def put_threshold(query, site, params) do
-    sample_threshold =
-      case params["sample_threshold"] do
-        nil ->
-          decide_sample_rate(site, query)
-
-        "infinite" ->
-          :no_sampling
-
-        value_string ->
-          {value, _} = Float.parse(value_string)
-          value
-      end
-
-    Map.put(query, :sample_threshold, sample_threshold)
-  end
-
-  defp decide_sample_rate(site, query) do
-    if Plausible.Sites.consolidated?(site) and not Enum.empty?(query.consolidated_site_ids) do
-      query.consolidated_site_ids
-      |> SamplingCache.consolidated_get()
-      |> fractional_sample_rate(query)
-    else
-      site.id
-      |> SamplingCache.get()
-      |> fractional_sample_rate(query)
-    end
-  end
-
-  def fractional_sample_rate(nil = _traffic_30_day, _query),
-    do: :no_sampling
-
-  def fractional_sample_rate(traffic_30_day, query) do
-    date_range = Query.date_range(query)
-    duration = Date.diff(date_range.last, date_range.first)
-
-    estimated_traffic = estimate_traffic(traffic_30_day, duration, query)
-
-    fraction =
-      if(estimated_traffic > 0,
-        do: Float.round(@default_sample_threshold / estimated_traffic, 2),
-        else: 1.0
-      )
-
-    cond do
-      # Don't sample small time ranges
-      duration < 1 -> :no_sampling
-      # If sampling doesn't have a significant effect, don't sample
-      fraction > 0.4 -> :no_sampling
-      true -> max(fraction, min_sample_rate())
-    end
-  end
-
-  defp min_sample_rate(), do: 0.013
-
-  defp estimate_traffic(traffic_30_day, duration, query) do
-    duration_adjusted_traffic = traffic_30_day / 30.0 * duration
-
-    estimate_by_filters(duration_adjusted_traffic, query.filters)
-  end
-
-  @filter_traffic_multiplier 1 / 4.0
-  @max_filters 2
-
-  defp estimate_by_filters(estimation, filters),
-    do: estimation * @filter_traffic_multiplier ** min(length(filters), @max_filters)
-end

extra/lib/plausible/stats/sampling_cache.ex

@@ -1,59 +0,0 @@
-defmodule Plausible.Stats.SamplingCache do
-  @moduledoc """
-  Cache storing estimation for events ingested by a site in the past month.
-
-  Used for sampling rate calculations in Plausible.Stats.Sampling.
-  """
-  alias Plausible.Ingestion
-
-  import Ecto.Query
-  use Plausible.Cache
-
-  @cache_name :stats_sampling_cache
-
-  @impl true
-  def name(), do: @cache_name
-
-  @impl true
-  def child_id(), do: :cache_stats_sampling
-
-  @impl true
-  def repo(), do: Plausible.ClickhouseRepo
-
-  @impl true
-  def count_all() do
-    base_db_query()
-    |> repo().all()
-    |> length()
-  end
-
-  @impl true
-  def base_db_query() do
-    from(r in Ingestion.Counters.Record,
-      select: {
-        r.site_id,
-        selected_as(fragment("sumIf(value, metric = 'buffered')"), :events_ingested)
-      },
-      where: fragment("toDate(event_timebucket) >= ?", ^thirty_days_ago()),
-      group_by: r.site_id
-    )
-  end
-
-  @impl true
-  def get_from_source(site_id) do
-    base_db_query()
-    |> repo().all()
-    |> Map.new()
-    |> Map.get(site_id)
-  end
-
-  @spec consolidated_get(list(pos_integer()), Keyword.t()) :: pos_integer() | nil
-  def consolidated_get(site_ids, opts \\ []) when is_list(site_ids) do
-    events_ingested = Enum.sum_by(site_ids, &(get(&1, opts) || 0))
-    if events_ingested > 0, do: events_ingested
-  end
-
-  defp thirty_days_ago() do
-    Date.shift(Date.utc_today(), day: -30)
-  end
-end

extra/lib/plausible/workers/score_trial_prospects.ex

@@ -1,101 +0,0 @@
-defmodule Plausible.Workers.ScoreTrialProspects do
-  @moduledoc """
-  Daily worker that scores the revenue potential of every team on (or just off)
-  a trial and caches the result in the `trial_prospects` table.
-  """
-  use Plausible.Repo
-
-  use Oban.Worker,
-    queue: :score_trial_prospects,
-    max_attempts: 1
-
-  require Logger
-
-  alias Plausible.Teams
-  alias Plausible.CustomerSupport.{TrialProspect, TrialProspects}
-
-  @max_expired_days 30
-
-  @impl Oban.Worker
-  def perform(_job) do
-    Date.utc_today()
-    |> trial_population()
-    |> Enum.each(&score_and_persist/1)
-
-    :ok
-  end
-
-  defp score_and_persist(team) do
-    try do
-      team
-      |> score_team()
-      |> upsert()
-    rescue
-      error ->
-        Logger.error(
-          "ScoreTrialProspects: skipping team #{team.id}: " <>
-            Exception.format(:error, error, __STACKTRACE__)
-        )
-    end
-  end
-
-  defp trial_population(today) do
-    cutoff = Date.add(today, -@max_expired_days)
-
-    Repo.all(
-      from t in Teams.Team,
-        left_join: s in assoc(t, :subscription),
-        where: not is_nil(t.trial_expiry_date),
-        where: is_nil(s.id),
-        where: t.trial_expiry_date >= ^cutoff
-    )
-  end
-
-  defp score_team(team) do
-    site_ids = Teams.owned_sites_ids(team)
-
-    traffic = Plausible.Stats.Clickhouse.trial_traffic(site_ids)
-
-    case traffic do
-      %{events_in_window: 0} -> nil
-      traffic -> build_row(team, traffic, site_ids)
-    end
-  end
-
-  defp build_row(team, traffic, site_ids) do
-    score =
-      TrialProspects.score(
-        traffic.estimated_monthly,
-        Teams.Billing.features_usage(team, site_ids),
-        length(site_ids),
-        Teams.Billing.team_member_usage(team)
-      )
-
-    now = DateTime.utc_now(:second)
-    naive_now = DateTime.to_naive(now)
-
-    %{
-      team_id: team.id,
-      estimated_monthly: traffic.estimated_monthly,
-      observed_days: traffic.observed_days,
-      first_data_day: traffic.first_data_day,
-      kind: score.kind,
-      forced_by: score.forced_by,
-      pageview_limit: score.pageview_limit,
-      over_top_tier: score.over_top_tier,
-      estimated_mrr: score.estimated_mrr,
-      computed_at: now,
-      inserted_at: naive_now,
-      updated_at: naive_now
-    }
-  end
-
-  defp upsert(nil), do: :ok
-
-  defp upsert(row) do
-    Repo.insert_all(TrialProspect, [row],
-      on_conflict: {:replace_all_except, [:id, :team_id, :inserted_at]},
-      conflict_target: :team_id
-    )
-  end
-end

extra/lib/plausible_web/controllers/api/external_sites_controller.ex

@@ -1,626 +0,0 @@
-defmodule PlausibleWeb.Api.ExternalSitesController do
-  use PlausibleWeb, :controller
-  use Plausible.Repo
-  use PlausibleWeb.Plugs.ErrorHandler
-
-  import Plausible.Pagination
-
-  alias Plausible.Sites
-  alias Plausible.Goal
-  alias Plausible.Goals
-  alias Plausible.Props
-  alias Plausible.Teams
-  alias PlausibleWeb.Api.Helpers, as: H
-
-  @pagination_opts [cursor_fields: [{:id, :desc}], limit: 100, maximum_limit: 1000]
-
-  def index(conn, params) do
-    user = conn.assigns.current_user
-    team = conn.assigns.current_team || Teams.get(params["team_id"])
-
-    page =
-      user
-      |> Sites.for_user_query(team)
-      |> paginate(params, @pagination_opts)
-
-    json(conn, %{
-      sites: page.entries |> Enum.map(&get_site_response_for_index/1),
-      meta: pagination_meta(page.metadata)
-    })
-  end
-
-  def guests_index(conn, params) do
-    user = conn.assigns.current_user
-    team = conn.assigns.current_team
-
-    with {:ok, site_id} <- expect_param_key(params, "site_id"),
-         {:ok, site} <- find_site(user, team, site_id, [:owner, :admin, :editor, :viewer]) do
-      opts = [cursor_fields: [sort_index: :asc], limit: 100, maximum_limit: 1000]
-      page = site |> Sites.list_guests_query() |> paginate(params, opts)
-
-      json(conn, %{
-        guests:
-          Enum.map(page.entries, fn entry ->
-            Map.take(entry, [:email, :role, :status])
-          end),
-        meta: pagination_meta(page.metadata)
-      })
-    else
-      {:missing, "site_id"} ->
-        H.bad_request(conn, "Parameter `site_id` is required to list goals")
-
-      {:error, :site_not_found} ->
-        H.not_found(conn, "Site could not be found")
-    end
-  end
-
-  def teams_index(conn, params) do
-    user = conn.assigns.current_user
-    team = conn.assigns.current_team
-
-    page =
-      user
-      |> Teams.Users.teams_query(identifier: team && team.identifier, order_by: :id_desc)
-      |> paginate(params, @pagination_opts)
-
-    json(conn, %{
-      teams:
-        Enum.map(page.entries, fn team ->
-          api_available? =
-            Plausible.Billing.Feature.StatsAPI.check_availability(team) == :ok
-
-          %{
-            id: team.identifier,
-            name: Teams.name(team),
-            api_available: api_available?
-          }
-        end),
-      meta: pagination_meta(page.metadata)
-    })
-  end
-
-  def goals_index(conn, params) do
-    user = conn.assigns.current_user
-    team = conn.assigns.current_team
-
-    with {:ok, site_id} <- expect_param_key(params, "site_id"),
-         {:ok, site} <- find_site(user, team, site_id, [:owner, :admin, :editor, :viewer]) do
-      page =
-        site
-        |> Plausible.Goals.for_site_query()
-        |> paginate(params, @pagination_opts)
-
-      json(conn, %{
-        goals:
-          Enum.map(page.entries, fn goal ->
-            %{
-              id: goal.id,
-              display_name: goal.display_name,
-              goal_type: Goal.type(goal),
-              event_name: goal.event_name,
-              page_path: goal.page_path,
-              custom_props: goal.custom_props
-            }
-          end),
-        meta: pagination_meta(page.metadata)
-      })
-    else
-      {:missing, "site_id"} ->
-        H.bad_request(conn, "Parameter `site_id` is required to list goals")
-
-      {:error, :site_not_found} ->
-        H.not_found(conn, "Site could not be found")
-    end
-  end
-
-  def create_site(conn, params) do
-    user = conn.assigns.current_user
-    team = conn.assigns.current_team || Teams.get(params["team_id"])
-
-    case Repo.transact(fn ->
-           with {:ok, %{site: site}} <- Sites.create(user, params, team),
-                {:ok, tracker_script_configuration} <-
-                  get_or_create_config(site, params["tracker_script_configuration"] || %{}) do
-             {:ok,
-              struct(site,
-                tracker_script_configuration: tracker_script_configuration
-              )}
-           else
-             # Translates Multi error format to Repo.transact error format
-             {:error, step_id, output, context} ->
-               {:error, {step_id, output, context}}
-
-             # already in Repo.transact error format
-             {:error, reason} ->
-               {:error, reason}
-           end
-         end) do
-      {:ok, site} ->
-        json(conn, get_site_response(site))
-
-      {:error, {_, {:over_limit, limit}, _}} ->
-        conn
-        |> put_status(402)
-        |> json(%{
-          error:
-            "Your account has reached the limit of #{limit} sites. To unlock more sites, please upgrade your subscription."
-        })
-
-      {:error, {_, :permission_denied, _}} ->
-        conn
-        |> put_status(403)
-        |> json(%{
-          error: "You can't add sites to the selected team."
-        })
-
-      {:error, {_, :multiple_teams, _}} ->
-        conn
-        |> put_status(400)
-        |> json(%{
-          error: "You must select a team with 'team_id' parameter."
-        })
-
-      {:error, {:tracker_script_configuration_invalid, %Ecto.Changeset{} = changeset}} ->
-        conn
-        |> put_status(400)
-        |> json(serialize_errors(changeset, "tracker_script_configuration."))
-
-      {:error, {_, %Ecto.Changeset{} = changeset, _}} ->
-        conn
-        |> put_status(400)
-        |> json(serialize_errors(changeset))
-    end
-  end
-
-  def get_site(conn, %{"site_id" => site_id}) do
-    user = conn.assigns.current_user
-    team = conn.assigns.current_team
-
-    with {:ok, site} <- find_site(user, team, site_id, [:owner, :admin, :editor, :viewer]),
-         {:ok, tracker_script_configuration} <- get_or_create_config(site, %{}) do
-      site = struct(site, tracker_script_configuration: tracker_script_configuration)
-
-      json(conn, get_site_response(site))
-    else
-      {:error, :site_not_found} ->
-        H.not_found(conn, "Site could not be found")
-    end
-  end
-
-  def delete_site(conn, %{"site_id" => site_id}) do
-    user = conn.assigns.current_user
-    team = conn.assigns.current_team
-
-    case find_site(user, team, site_id, [:owner]) do
-      {:ok, site} ->
-        {:ok, _} = Plausible.Site.Removal.run(site)
-        json(conn, %{"deleted" => true})
-
-      {:error, :site_not_found} ->
-        H.not_found(conn, "Site could not be found")
-    end
-  end
-
-  def update_site(conn, %{"site_id" => site_id} = params) do
-    user = conn.assigns.current_user
-    team = conn.assigns.current_team
-
-    with {:ok, params} <- validate_update_payload(params),
-         {:ok, site} <- find_site(user, team, site_id, [:owner, :admin, :editor]),
-         {:ok, site} <- do_update_site(site, params) do
-      json(conn, get_site_response(site))
-    else
-      {:error, :site_not_found} ->
-        H.not_found(conn, "Site could not be found")
-
-      {:error, :no_changes} ->
-        H.bad_request(
-          conn,
-          "Payload must contain at least one of the parameters 'domain', 'tracker_script_configuration'"
-        )
-
-      {:error, {:domain_change_invalid, %Ecto.Changeset{} = changeset}} ->
-        conn
-        |> put_status(400)
-        |> json(serialize_errors(changeset))
-
-      {:error, {:tracker_script_configuration_invalid, %Ecto.Changeset{} = changeset}} ->
-        conn
-        |> put_status(400)
-        |> json(serialize_errors(changeset, "tracker_script_configuration."))
-    end
-  end
-
-  defp validate_update_payload(params) do
-    params = params |> Map.take(["domain", "tracker_script_configuration"]) |> Map.drop([nil])
-
-    if map_size(params) == 0 do
-      {:error, :no_changes}
-    else
-      {:ok, params}
-    end
-  end
-
-  defp do_update_site(site, params) do
-    Repo.transact(fn ->
-      with {:ok, site} <-
-             if(params["domain"],
-               do: change_domain(site, params["domain"]),
-               else: {:ok, site}
-             ),
-           {:ok, tracker_script_configuration} <-
-             if(params["tracker_script_configuration"],
-               do: update_config(site, params["tracker_script_configuration"]),
-               else: get_or_create_config(site, %{})
-             ) do
-        {:ok, struct(site, tracker_script_configuration: tracker_script_configuration)}
-      end
-    end)
-  end
-
-  defp change_domain(site, domain) do
-    case Plausible.Site.Domain.change(site, domain) do
-      {:ok, site} ->
-        {:ok, site}
-
-      {:error, %Ecto.Changeset{} = changeset} ->
-        {:error, {:domain_change_invalid, changeset}}
-    end
-  end
-
-  def find_or_create_guest(conn, params) do
-    user = conn.assigns.current_user
-    team = conn.assigns.current_team
-
-    with {:ok, site_id} <- expect_param_key(params, "site_id"),
-         {:ok, email} <- expect_param_key(params, "email"),
-         {:ok, role} <- expect_param_key(params, "role", ["viewer", "editor"]),
-         {:ok, site} <- find_site(user, team, site_id, [:owner, :admin]) do
-      existing = Repo.one(Sites.list_guests_query(site, email: email))
-
-      if existing do
-        json(conn, %{
-          role: existing.role,
-          email: existing.email,
-          status: existing.status
-        })
-      else
-        case Teams.Invitations.InviteToSite.invite(
-               site,
-               conn.assigns.current_user,
-               email,
-               role
-             ) do
-          {:ok, invitation} ->
-            json(conn, %{
-              role: invitation.role,
-              email: invitation.team_invitation.email,
-              status: "invited"
-            })
-        end
-      end
-    else
-      {:error, :site_not_found} ->
-        H.not_found(conn, "Site could not be found")
-
-      {:missing, "role"} ->
-        H.bad_request(
-          conn,
-          "Parameter `role` is required to create guest. Possible values: `viewer` or `editor`"
-        )
-
-      {:missing, param} ->
-        H.bad_request(conn, "Parameter `#{param}` is required to create guest")
-    end
-  end
-
-  def delete_guest(conn, params) do
-    user = conn.assigns.current_user
-    team = conn.assigns.current_team
-
-    with {:ok, site_id} <- expect_param_key(params, "site_id"),
-         {:ok, email} <- expect_param_key(params, "email"),
-         {:ok, site} <- find_site(user, team, site_id, [:owner, :admin]) do
-      existing = Repo.one(Sites.list_guests_query(site, email: email))
-
-      case existing do
-        %{status: "invited", id: id} ->
-          with guest_invitation when not is_nil(guest_invitation) <-
-                 Repo.get(Teams.GuestInvitation, id) do
-            Teams.Invitations.remove_guest_invitation(guest_invitation)
-          end
-
-        %{status: "accepted", email: email} ->
-          with %{} = user <- Repo.get_by(Plausible.Auth.User, email: email) do
-            Teams.Memberships.remove(site, user)
-          end
-
-        _ ->
-          :ignore
-      end
-
-      json(conn, %{"deleted" => true})
-    else
-      {:error, :site_not_found} ->
-        H.not_found(conn, "Site could not be found")
-
-      {:missing, param} ->
-        H.bad_request(conn, "Parameter `#{param}` is required to delete a guest")
-    end
-  end
-
-  def find_or_create_shared_link(conn, params) do
-    user = conn.assigns.current_user
-    team = conn.assigns.current_team
-
-    with {:ok, site_id} <- expect_param_key(params, "site_id"),
-         {:ok, link_name} <- expect_param_key(params, "name"),
-         {:ok, site} <- find_site(user, team, site_id, [:owner, :admin, :editor]) do
-      shared_link = Repo.get_by(Plausible.Site.SharedLink, site_id: site.id, name: link_name)
-
-      shared_link =
-        case shared_link do
-          nil -> Sites.create_shared_link(site, link_name)
-          link -> {:ok, link}
-        end
-
-      case shared_link do
-        {:ok, link} ->
-          json(conn, %{
-            name: link.name,
-            url: Sites.shared_link_url(site, link)
-          })
-
-        {:error, %Ecto.Changeset{} = changeset} ->
-          {msg, _} = changeset.errors[:name]
-          H.bad_request(conn, msg)
-
-        {:error, :upgrade_required} ->
-          H.payment_required(conn, "Your current subscription plan does not include Shared Links")
-      end
-    else
-      {:error, :site_not_found} ->
-        H.not_found(conn, "Site could not be found")
-
-      {:missing, "site_id"} ->
-        H.bad_request(conn, "Parameter `site_id` is required to create a shared link")
-
-      {:missing, "name"} ->
-        H.bad_request(conn, "Parameter `name` is required to create a shared link")
-
-      e ->
-        H.bad_request(conn, "Something went wrong: #{inspect(e)}")
-    end
-  end
-
-  def find_or_create_goal(conn, params) do
-    user = conn.assigns.current_user
-    team = conn.assigns.current_team
-
-    with {:ok, site_id} <- expect_param_key(params, "site_id"),
-         {:ok, _} <- expect_param_key(params, "goal_type"),
-         {:ok, site} <- find_site(user, team, site_id, [:owner, :admin, :editor]),
-         {:ok, goal} <- Goals.find_or_create(site, params) do
-      json(conn, goal)
-    else
-      {:error, :site_not_found} ->
-        H.not_found(conn, "Site could not be found")
-
-      {:missing, param} ->
-        H.bad_request(conn, "Parameter `#{param}` is required to create a goal")
-
-      {:error, %Ecto.Changeset{} = changeset} ->
-        message = Enum.map_join(changeset.errors, ", ", &translate_error/1)
-
-        H.bad_request(conn, message)
-
-      {:error, :upgrade_required} ->
-        H.payment_required(
-          conn,
-          "Your current subscription plan does not include Custom Properties"
-        )
-
-      e ->
-        H.bad_request(conn, "Something went wrong: #{inspect(e)}")
-    end
-  end
-
-  def delete_goal(conn, params) do
-    user = conn.assigns.current_user
-    team = conn.assigns.current_team
-
-    with {:ok, site_id} <- expect_param_key(params, "site_id"),
-         {:ok, goal_id} <- expect_param_key(params, "goal_id"),
-         {:ok, site} <- find_site(user, team, site_id, [:owner, :admin, :editor]),
-         :ok <- Goals.delete(goal_id, site) do
-      json(conn, %{"deleted" => true})
-    else
-      {:error, :site_not_found} ->
-        H.not_found(conn, "Site could not be found")
-
-      {:error, :not_found} ->
-        H.not_found(conn, "Goal could not be found")
-
-      {:missing, "site_id"} ->
-        H.bad_request(conn, "Parameter `site_id` is required to delete a goal")
-
-      {:missing, "goal_id"} ->
-        H.bad_request(conn, "Parameter `goal_id` is required to delete a goal")
-
-      e ->
-        H.bad_request(conn, "Something went wrong: #{inspect(e)}")
-    end
-  end
-
-  def custom_props_index(conn, params) do
-    user = conn.assigns.current_user
-    team = conn.assigns.current_team
-
-    with {:ok, site_id} <- expect_param_key(params, "site_id"),
-         {:ok, site} <- find_site(user, team, site_id, [:owner, :admin, :editor, :viewer]) do
-      properties =
-        (site.allowed_event_props || [])
-        |> Enum.sort()
-        |> Enum.map(fn prop -> %{property: prop} end)
-
-      json(conn, %{custom_properties: properties})
-    else
-      {:error, :site_not_found} ->
-        H.not_found(conn, "Site could not be found")
-
-      {:missing, "site_id"} ->
-        H.bad_request(conn, "Parameter `site_id` is required to list custom properties")
-    end
-  end
-
-  def add_custom_prop(conn, params) do
-    user = conn.assigns.current_user
-    team = conn.assigns.current_team
-
-    with {:ok, site_id} <- expect_param_key(params, "site_id"),
-         {:ok, property} <- expect_param_key(params, "property"),
-         {:ok, site} <- find_site(user, team, site_id, [:owner, :admin, :editor]),
-         {:ok, _} <- Props.allow(site, property) do
-      json(conn, %{"created" => true})
-    else
-      {:error, :site_not_found} ->
-        H.not_found(conn, "Site could not be found")
-
-      {:missing, param} ->
-        H.bad_request(conn, "Parameter `#{param}` is required to create a custom property")
-
-      {:error, :upgrade_required} ->
-        H.payment_required(
-          conn,
-          "Your current subscription plan does not include Custom Properties"
-        )
-
-      {:error, changeset} ->
-        %{allowed_event_props: [error | _]} =
-          Ecto.Changeset.traverse_errors(changeset, fn {_msg, opts} ->
-            cond do
-              opts[:type] == :list and opts[:validation] == :length ->
-                "Can't add any more custom properties"
-
-              opts[:type] == :string and opts[:validation] == :length ->
-                "Parameter `property` is too long"
-
-              true ->
-                "Parameter `property` is invalid"
-            end
-          end)
-
-        H.bad_request(conn, error)
-    end
-  end
-
-  def delete_custom_prop(conn, params) do
-    user = conn.assigns.current_user
-    team = conn.assigns.current_team
-
-    with {:ok, site_id} <- expect_param_key(params, "site_id"),
-         {:ok, property} <- expect_param_key(params, "property"),
-         # Property name is extracted from route URL via wildcard,
-         # which returns a list.
-         property = Path.join(property),
-         {:ok, site} <- find_site(user, team, site_id, [:owner, :admin, :editor]),
-         {:ok, _} <- Props.disallow(site, property) do
-      json(conn, %{"deleted" => true})
-    else
-      {:error, :site_not_found} ->
-        H.not_found(conn, "Site could not be found")
-
-      {:missing, param} ->
-        H.bad_request(conn, "Parameter `#{param}` is required to delete a custom property")
-
-      e ->
-        H.bad_request(conn, "Something went wrong: #{inspect(e)}")
-    end
-  end
-
-  defp pagination_meta(meta) do
-    %{
-      after: meta.after,
-      before: meta.before,
-      limit: meta.limit
-    }
-  end
-
-  defp find_site(user, team, site_id, roles) do
-    case Plausible.Sites.get_for_user(user, site_id, roles: roles) do
-      nil ->
-        {:error, :site_not_found}
-
-      site ->
-        site = Repo.preload(site, :team)
-
-        if team && team.id != site.team_id do
-          {:error, :site_not_found}
-        else
-          {:ok, site}
-        end
-    end
-  end
-
-  defp serialize_errors(changeset, field_prefix \\ "") do
-    {field, {msg, _opts}} = List.first(changeset.errors)
-    error_msg = field_prefix <> Atom.to_string(field) <> ": " <> msg
-    %{"error" => error_msg}
-  end
-
-  defp expect_param_key(params, key, inclusion \\ [])
-
-  defp expect_param_key(params, key, []) do
-    case Map.fetch(params, key) do
-      :error -> {:missing, key}
-      res -> res
-    end
-  end
-
-  defp expect_param_key(params, key, inclusion) do
-    case expect_param_key(params, key, []) do
-      {:ok, value} = ok ->
-        if value in inclusion, do: ok, else: {:missing, key}
-
-      _ ->
-        {:missing, key}
-    end
-  end
-
-  defp get_or_create_config(site, params) do
-    case PlausibleWeb.Tracker.get_or_create_tracker_script_configuration(site, params) do
-      {:ok, tracker_script_configuration} ->
-        {:ok, tracker_script_configuration}
-
-      {:error, %Ecto.Changeset{} = changeset} ->
-        {:error, {:tracker_script_configuration_invalid, changeset}}
-    end
-  end
-
-  defp update_config(site, params) do
-    case PlausibleWeb.Tracker.update_script_configuration(site, params, :installation) do
-      {:ok, tracker_script_configuration} ->
-        {:ok, tracker_script_configuration}
-
-      {:error, %Ecto.Changeset{} = changeset} ->
-        {:error, {:tracker_script_configuration_invalid, changeset}}
-    end
-  end
-
-  defp get_site_response_for_index(site) do
-    site |> Map.take([:domain, :timezone])
-  end
-
-  defp get_site_response(site) do
-    site
-    |> Map.take([:domain, :timezone, :tracker_script_configuration])
-    # remap to `custom_properties`
-    |> Map.put(:custom_properties, site.allowed_event_props || [])
-  end
-
-  defp translate_error({field, {msg, opts}}) do
-    Enum.reduce(opts, "#{field}: #{msg}", fn {key, value}, acc ->
-      String.replace(acc, "%{#{key}}", fn _ -> to_string(value) end)
-    end)
-  end
-end

extra/lib/plausible_web/controllers/api/revenue.ex

@@ -1,27 +0,0 @@
-defmodule PlausibleWeb.Controllers.API.Revenue do
-  @moduledoc """
-  Revenue specific functions for the API scope
-  """
-
-  @revenue_metrics Plausible.Stats.Goal.Revenue.revenue_metrics()
-  def format_revenue_metric({metric, value}) do
-    if metric in @revenue_metrics do
-      {metric, format_money(value)}
-    else
-      {metric, value}
-    end
-  end
-
-  def format_money(value) do
-    case value do
-      %Money{} ->
-        %{
-          short: Money.to_string!(value, format: :short, fractional_digits: 1),
-          long: Money.to_string!(value)
-        }
-
-      _any ->
-        value
-    end
-  end
-end

extra/lib/plausible_web/controllers/help_scout_controller.ex

@@ -1,121 +0,0 @@
-defmodule PlausibleWeb.HelpScoutController do
-  use PlausibleWeb, :controller
-
-  alias Plausible.HelpScout
-
-  @conversation_token_seconds 8 * 60 * 60
-
-  plug :make_iframe_friendly
-
-  def callback(conn, %{"customer-id" => customer_id, "conversation-id" => conversation_id}) do
-    assigns = %{conversation_id: conversation_id, customer_id: customer_id, token: ""}
-
-    with :ok <- HelpScout.validate_signature(conn),
-         {:ok, details} <- HelpScout.get_details_for_customer(customer_id, conversation_id) do
-      assigns = Map.put(assigns, :token, sign_token(conversation_id))
-
-      conn
-      |> render("callback.html", Map.merge(assigns, details))
-    else
-      {:error, {:user_not_found, [email | _]}} ->
-        conn
-        |> render("callback.html", Map.merge(assigns, %{error: ":user_not_found", email: email}))
-
-      {:error, error} ->
-        conn
-        |> render("callback.html", Map.put(assigns, :error, inspect(error)))
-    end
-  end
-
-  def callback(conn, _) do
-    render(conn, "bad_request.html")
-  end
-
-  def show(
-        conn,
-        %{
-          "email" => email,
-          "token" => token,
-          "conversation_id" => conversation_id,
-          "customer_id" => customer_id
-        } =
-          params
-      ) do
-    assigns = %{
-      xhr?: params["xhr"] == "true",
-      conversation_id: conversation_id,
-      customer_id: customer_id,
-      token: token
-    }
-
-    with :ok <- match_conversation(token, conversation_id),
-         {:ok, details} <-
-           HelpScout.get_details_for_emails(
-             [email],
-             customer_id,
-             conversation_id,
-             params["team_identifier"]
-           ) do
-      render(conn, "callback.html", Map.merge(assigns, details))
-    else
-      {:error, error} ->
-        render(conn, "callback.html", Map.put(assigns, :error, inspect(error)))
-    end
-  end
-
-  def search(conn, %{
-        "term" => term,
-        "token" => token,
-        "conversation_id" => conversation_id,
-        "customer_id" => customer_id
-      }) do
-    assigns = %{
-      conversation_id: conversation_id,
-      customer_id: customer_id,
-      token: token
-    }
-
-    case match_conversation(token, conversation_id) do
-      :ok ->
-        users = HelpScout.search_users(term, customer_id, conversation_id)
-        render(conn, "search.html", Map.merge(assigns, %{users: users, term: term}))
-
-      {:error, error} ->
-        render(conn, "search.html", Map.put(assigns, :error, inspect(error)))
-    end
-  end
-
-  defp match_conversation(token, conversation_id) do
-    case verify_token(token) do
-      {:ok, token_data} ->
-        if token_data.conversation_id == conversation_id do
-          :ok
-        else
-          {:error, :invalid_conversation}
-        end
-
-      {:error, _error} ->
-        {:error, :invalid_token}
-    end
-  end
-
-  # Exposed for testing
-  @doc false
-  def sign_token(conversation_id) do
-    Phoenix.Token.sign(PlausibleWeb.Endpoint, "hs-conversation", %{
-      conversation_id: conversation_id
-    })
-  end
-
-  defp verify_token(token) do
-    Phoenix.Token.verify(PlausibleWeb.Endpoint, "hs-conversation", token,
-      max_age: @conversation_token_seconds
-    )
-  end
-
-  defp make_iframe_friendly(conn, _opts) do
-    conn
-    |> delete_resp_header("x-frame-options")
-    |> put_root_layout(html: {PlausibleWeb.HelpScoutView, :layout})
-  end
-end

extra/lib/plausible_web/controllers/sso_controller.ex

@@ -1,140 +0,0 @@
-defmodule PlausibleWeb.SSOController do
-  use PlausibleWeb, :controller
-
-  require Logger
-
-  alias Plausible.Auth
-  alias Plausible.Auth.SSO
-  alias PlausibleWeb.LoginPreference
-
-  alias PlausibleWeb.Router.Helpers, as: Routes
-
-  plug Plausible.Plugs.AuthorizeTeamAccess,
-       [:owner] when action in [:sso_settings]
-
-  plug Plausible.Plugs.AuthorizeTeamAccess,
-       [:owner, :admin] when action in [:team_sessions, :delete_session]
-
-  def login_form(conn, params) do
-    login_preference = LoginPreference.get(conn)
-    error = Phoenix.Flash.get(conn.assigns.flash, :login_error)
-
-    case {login_preference, params["prefer"], error} do
-      {nil, nil, nil} ->
-        redirect(conn, to: Routes.auth_path(conn, :login_form, return_to: params["return_to"]))
-
-      _ ->
-        render_auth_page(conn, "login_form.html",
-          autosubmit: params["autosubmit"] != nil,
-          heading: "Sign in with SSO"
-        )
-    end
-  end
-
-  def login(conn, %{"email" => email} = params) do
-    with :ok <- Auth.rate_limit(:login_ip, conn),
-         {:ok, %{sso_integration: integration}} <- SSO.Domains.lookup(email) do
-      redirect(conn,
-        to:
-          Routes.sso_path(
-            conn,
-            :saml_signin,
-            integration.identifier,
-            email: email,
-            return_to: params["return_to"]
-          )
-      )
-    else
-      {:error, :not_found} ->
-        conn
-        |> put_flash(
-          :login_error,
-          "We couldn't find a Single Sign-On account for that email."
-        )
-        |> redirect(to: Routes.sso_path(conn, :login_form))
-
-      {:error, {:rate_limit, _}} ->
-        Auth.log_failed_login_attempt("too many login attempts for #{email}")
-
-        render_error(
-          conn,
-          429,
-          "Too many login attempts. Wait a minute before trying again."
-        )
-    end
-  end
-
-  def provision_notice(conn, _params) do
-    render_auth_page(conn, "provision_notice.html", heading: "Single Sign-On required")
-  end
-
-  def provision_issue(conn, params) do
-    issue =
-      case params["issue"] do
-        "not_a_member" -> :not_a_member
-        "multiple_memberships" -> :multiple_memberships
-        "multiple_memberships_noforce" -> :multiple_memberships_noforce
-        "active_personal_team" -> :active_personal_team
-        "active_personal_team_noforce" -> :active_personal_team_noforce
-        _ -> :unknown
-      end
-
-    render_auth_page(conn, "provision_issue.html",
-      heading: "Single Sign-On required",
-      issue: issue
-    )
-  end
-
-  def saml_signin(conn, params) do
-    saml_adapter().signin(conn, params)
-  end
-
-  def saml_consume(conn, params) do
-    saml_adapter().consume(conn, params)
-  end
-
-  def csp_report(conn, _params) do
-    {:ok, body, conn} = Plug.Conn.read_body(conn)
-    Logger.error(body)
-    conn |> send_resp(200, "OK")
-  end
-
-  def cta(conn, _params) do
-    render(conn, :cta, layout: {PlausibleWeb.LayoutView, :settings})
-  end
-
-  def sso_settings(conn, _params) do
-    if Plausible.Teams.setup?(conn.assigns.current_team) and
-         Plausible.Billing.Feature.SSO.check_availability(conn.assigns.current_team) == :ok do
-      render(conn, :sso_settings,
-        layout: {PlausibleWeb.LayoutView, :settings},
-        connect_live_socket: true
-      )
-    else
-      conn
-      |> redirect(to: Routes.site_path(conn, :index))
-    end
-  end
-
-  def team_sessions(conn, _params) do
-    sso_sessions = Auth.UserSessions.list_sso_for_team(conn.assigns.current_team)
-
-    render(conn, :team_sessions,
-      layout: {PlausibleWeb.LayoutView, :settings},
-      sso_sessions: sso_sessions
-    )
-  end
-
-  def delete_session(conn, %{"session_id" => session_id}) do
-    current_team = conn.assigns.current_team
-    Auth.UserSessions.revoke_sso_by_id(current_team, session_id)
-
-    conn
-    |> put_flash(:success, "Session logged out successfully")
-    |> redirect(to: Routes.sso_path(conn, :team_sessions))
-  end
-
-  defp saml_adapter() do
-    Application.fetch_env!(:plausible, :sso_saml_adapter)
-  end
-end

extra/lib/plausible_web/dogfood.ex

@@ -1,96 +0,0 @@
-defmodule PlausibleWeb.Dogfood do
-  @moduledoc """
-  Plausible tracking itself functions
-  """
-
-  def script_params(assigns) do
-    %{
-      script_url: script_url(assigns),
-      domain_to_replace: domain_to_replace(assigns),
-      location_override: location_override(assigns),
-      custom_properties: custom_properties(assigns),
-      capture_on_localhost: Application.get_env(:plausible, :environment) == "dev"
-    }
-  end
-
-  defp script_url(assigns) do
-    env = Application.get_env(:plausible, :environment)
-    selfhost? = Application.get_env(:plausible, :is_selfhost)
-
-    tracker_script_config_id =
-      cond do
-        env == "prod" and selfhost? ->
-          "pa-V5OUguy5m04s95qHnmGbH"
-
-        env == "prod" and assigns[:embedded] ->
-          "pa-Qo3A7Ksnbn-wYQWMijuR3"
-
-        env == "prod" ->
-          "pa-6_srOGVV9SLMWJ1ZpUAbG"
-
-        env == "staging" ->
-          "pa-egYOCIzzYzPL9v6GHLc-7"
-
-        env in ["dev", "ce_dev"] ->
-          # By default we're not letting the app track itself on localhost.
-          # The requested script will be `.js` and the server will respond with 404.
-          # If you wish to track the app itself, uncomment the following code
-          # and replace the site_id if necessary (1 stands for dummy.site).
-
-          # Plausible.Repo.get(Plausible.Site, 1)
-          # |> PlausibleWeb.Tracker.get_or_create_tracker_script_configuration!()
-          # |> Map.get(:id)
-
-          "pa-invalid-script-id"
-
-        env in ["test", "ce_test", "e2e_test"] ->
-          ""
-      end
-
-    "#{PlausibleWeb.Endpoint.url()}/js/#{tracker_script_config_id}.js"
-  end
-
-  # TRICKY: The React dashboard uses history-based SPA navigation
-  # which triggers pageviews on routes that the backend is unaware
-  # of (e.g.`/:domain/pages`). As opposed to other site paths like
-  # `/:domain/settings/general` we cannot override the entire URL.
-  # To still make sure we're not capturing customer domains we run
-  # a string replace in `payload.u`.
-  defp domain_to_replace(assigns) do
-    if not is_nil(assigns[:site]) and assigns[:demo] != true do
-      URI.encode_www_form(assigns.site.domain)
-    end
-  end
-
-  defp location_override(%{dogfood_page_path: path}) when is_binary(path) do
-    Path.join(PlausibleWeb.Endpoint.url(), path)
-  end
-
-  defp location_override(_), do: nil
-
-  defp custom_properties(%{current_user: user} = assigns) when is_map(user) do
-    %{
-      logged_in: true,
-      theme: user.theme,
-      current_plan: current_plan(assigns[:current_team])
-    }
-  end
-
-  defp custom_properties(_) do
-    %{logged_in: false}
-  end
-
-  defp current_plan(%Plausible.Teams.Team{
-         subscription: %Plausible.Billing.Subscription{} = subscription
-       }) do
-    case Plausible.Billing.Plans.get_subscription_plan(subscription) do
-      %Plausible.Billing.Plan{kind: kind} -> kind
-      %Plausible.Billing.EnterprisePlan{} -> :enterprise
-      other when is_atom(other) -> other
-    end
-  end
-
-  defp current_plan(team) do
-    if Plausible.Teams.on_trial?(team), do: :trial
-  end
-end

extra/lib/plausible_web/live/customer_support.ex

@@ -1,74 +0,0 @@
-defmodule PlausibleWeb.Live.CustomerSupport do
-  @moduledoc """
-  Customer Support home page (search)
-  """
-  use PlausibleWeb, :live_view
-
-  alias PlausibleWeb.CustomerSupport.Components.{Layout, Search}
-
-  @impl true
-  def mount(params, _session, socket) do
-    uri =
-      Routes.customer_support_path(
-        PlausibleWeb.Endpoint,
-        :index,
-        Map.take(params, ["filter_text"])
-      )
-      |> URI.new!()
-
-    {:ok,
-     assign(socket,
-       uri: uri,
-       filter_text: params["filter_text"] || ""
-     )}
-  end
-
-  @impl true
-  def handle_params(params, _uri, socket) do
-    filter_text = params["filter_text"] || ""
-    socket = assign(socket, filter_text: filter_text)
-
-    send_update(Search, id: "search-component", filter_text: filter_text)
-
-    {:noreply, socket}
-  end
-
-  @impl true
-  def render(assigns) do
-    ~H"""
-    <.flash_messages flash={@flash} />
-
-    <Layout.layout filter_text={@filter_text}>
-      <.live_component module={Search} filter_text={@filter_text} id="search-component" />
-    </Layout.layout>
-    """
-  end
-
-  @impl true
-  def handle_event("filter", %{"filter-text" => input}, socket) do
-    socket = set_filter_text(socket, input)
-    {:noreply, socket}
-  end
-
-  def handle_event("reset-filter-text", _params, socket) do
-    socket = set_filter_text(socket, "")
-    {:noreply, socket}
-  end
-
-  defp set_filter_text(socket, filter_text) do
-    uri = socket.assigns.uri
-
-    uri_params =
-      (uri.query || "")
-      |> URI.decode_query()
-      |> Map.put("filter_text", filter_text)
-      |> URI.encode_query()
-
-    uri = %{uri | query: uri_params}
-
-    socket
-    |> assign(:filter_text, filter_text)
-    |> assign(:uri, uri)
-    |> push_patch(to: URI.to_string(uri), replace: true)
-  end
-end

extra/lib/plausible_web/live/customer_support/components/layout.ex

@@ -1,124 +0,0 @@
-defmodule PlausibleWeb.CustomerSupport.Components.Layout do
-  @moduledoc """
-  Base layout component for Customer Support UI
-  Provides common header, filter bar, and content area structure
-  """
-  use PlausibleWeb, :component
-  import PlausibleWeb.Live.Flash
-
-  attr :filter_text, :string, default: ""
-  attr :show_search, :boolean, default: true
-  attr :flash, :map, default: %{}
-  slot :inner_block, required: true
-  slot :filter_actions, required: false
-
-  def layout(assigns) do
-    ~H"""
-    <div x-data="{ openHelp: false }" class="dark:text-gray-400">
-      <.help_overlay />
-
-      <div class="container pt-6">
-        <.header filter_text={@filter_text} />
-
-        <div class="py-4">
-          <.styled_link class="text-sm" onclick="window.history.go(-1); return false;">
-            &larr; Go back
-          </.styled_link>
-        </div>
-
-        <.search_bar :if={@show_search} filter_text={@filter_text}>
-          {render_slot(@filter_actions)}
-        </.search_bar>
-
-        <.flash_messages flash={@flash} />
-
-        <div class="mt-4">
-          {render_slot(@inner_block)}
-        </div>
-
-        <div class="py-4">
-          <.styled_link class="text-sm" onclick="window.history.go(-1); return false;">
-            &larr; Go back
-          </.styled_link>
-        </div>
-      </div>
-    </div>
-    """
-  end
-
-  defp help_overlay(assigns) do
-    ~H"""
-    <div
-      id="help"
-      x-show="openHelp"
-      x-cloak
-      class="p-16 fixed top-0 left-0 w-full h-full bg-gray-800/95 text-gray-300 z-50 flex items-center justify-center"
-    >
-      <div @click.away="openHelp = false" @click="openHelp = false">
-        Prefix your searches with: <br /><br />
-        <div class="font-mono">
-          <strong>site:</strong>input<br />
-          <p class="font-sans pl-2 mb-1">
-            Search for sites exclusively. Input will be checked against site's domain, team's name, owners' names and e-mails (fuzzy match) or against tracker script ID (exact match).
-          </p>
-          <strong>user:</strong>input<br />
-          <p class="font-sans pl-2 mb-1">
-            Search for users exclusively. Input will be checked against user's name and e-mail.
-          </p>
-          <strong>team:</strong>input<br />
-          <p class="font-sans pl-2 mb-1">
-            Search for teams exclusively. Input will be checked against user/team name, e-mail or team identifier. Identifier must be provided complete, as is.
-          </p>
-
-          <strong>team:</strong>input <strong>+sub</strong>
-          <br />
-          <p class="font-sans pl-2 mb-1">
-            Like above, but only finds team(s) with subscription (in any status).
-          </p>
-
-          <strong>team:</strong>input <strong>+sso</strong>
-          <br />
-          <p class="font-sans pl-2 mb-1">
-            Like above, but only finds team(s) with SSO integrations (in any status).
-          </p>
-        </div>
-      </div>
-    </div>
-    """
-  end
-
-  attr :filter_text, :string, required: true
-
-  defp header(assigns) do
-    ~H"""
-    <div class="group mt-6 pb-5 border-b border-gray-200 dark:border-gray-500 flex items-center justify-between">
-      <h2 class="text-2xl font-bold leading-7 text-gray-900 dark:text-gray-100 sm:text-3xl sm:leading-9 sm:truncate flex-shrink-0">
-        <.link
-          replace
-          patch={
-            Routes.customer_support_path(PlausibleWeb.Endpoint, :index, %{filter_text: @filter_text})
-          }
-        >
-          💬 Customer Support
-        </.link>
-      </h2>
-    </div>
-    """
-  end
-
-  attr :filter_text, :string, required: true
-  slot :inner_block, required: false
-
-  defp search_bar(assigns) do
-    ~H"""
-    <div class="mb-4 mt-4">
-      <.filter_bar filter_text={@filter_text} placeholder="Search everything">
-        <a class="cursor-pointer" @click="openHelp = !openHelp">
-          <Heroicons.question_mark_circle class="text-indigo-700 dark:text-gray-500 w-5 h-5 hover:stroke-2" />
-        </a>
-        {render_slot(@inner_block)}
-      </.filter_bar>
-    </div>
-    """
-  end
-end

extra/lib/plausible_web/live/customer_support/components/search.ex

@@ -1,125 +0,0 @@
-defmodule PlausibleWeb.CustomerSupport.Components.Search do
-  @moduledoc """
-  Dedicated search component for Customer Support
-  Handles search logic independently from other components
-  """
-  use PlausibleWeb, :live_component
-
-  alias Plausible.CustomerSupport.Resource
-  alias PlausibleWeb.CustomerSupport.Components.SearchResult
-
-  @resources [Resource.Team, Resource.User, Resource.Site]
-
-  def update(%{filter_text: filter_text} = assigns, socket) do
-    socket = assign(socket, assigns)
-    {:ok, perform_search(socket, filter_text)}
-  end
-
-  def handle_event("search-updated", %{"filter_text" => filter_text}, socket) do
-    {:noreply, perform_search(socket, filter_text)}
-  end
-
-  def render(assigns) do
-    ~H"""
-    <div>
-      <ul :if={@results != []} class="my-6 grid grid-cols-1 gap-6 sm:grid-cols-2 lg:grid-cols-3">
-        <li :for={r <- @results} class="group relative">
-          <.link patch={r.path} data-test-type={r.type} data-test-id={r.id}>
-            <div class="col-span-1 bg-white dark:bg-gray-800 rounded-lg shadow p-4 group-hover:shadow-lg cursor-pointer">
-              <div class="text-gray-800 dark:text-gray-500 w-full flex items-center justify-between space-x-4">
-                <.render_result resource={r} />
-              </div>
-            </div>
-          </.link>
-        </li>
-      </ul>
-
-      <div
-        :if={@results == [] && String.trim(@filter_text) != ""}
-        class="text-center py-8 text-gray-500"
-      >
-        No results found for "{@filter_text}"
-      </div>
-
-      <div
-        :if={@results == [] && String.trim(@filter_text) == ""}
-        class="text-center py-8 text-gray-500"
-      >
-        Enter a search term to find teams, users, or sites
-      </div>
-    </div>
-    """
-  end
-
-  def render_result(assigns) do
-    SearchResult.render_result(assigns)
-  end
-
-  defp perform_search(socket, filter_text) do
-    results = spawn_searches(filter_text)
-    assign(socket, :results, results)
-  end
-
-  defp spawn_searches(input) do
-    input = String.trim(input)
-
-    {resources, input, opts} =
-      maybe_focus_search(input)
-
-    resources
-    |> Task.async_stream(fn resource ->
-      input
-      |> resource.search(opts)
-      |> Enum.map(&resource.dump/1)
-    end)
-    |> Enum.reduce([], fn {:ok, results}, acc ->
-      acc ++ results
-    end)
-  end
-
-  defp maybe_focus_search(lone_modifier) when lone_modifier in ["site:", "team:", "user:"] do
-    {[], "", limit: 0}
-  end
-
-  defp maybe_focus_search("site:" <> rest) do
-    {[Resource.Site], rest, limit: 90}
-  end
-
-  defp maybe_focus_search("team:" <> rest) do
-    [input | mods] = String.split(rest, "+", trim: true)
-    input = String.trim(input)
-
-    opts =
-      if "sub" in mods do
-        [limit: 90, with_subscription_only?: true]
-      else
-        [limit: 90]
-      end
-
-    opts =
-      if "sso" in mods do
-        Keyword.merge(opts, with_sso_only?: true)
-      else
-        opts
-      end
-
-    opts =
-      case Ecto.UUID.cast(input) do
-        {:ok, _uuid} ->
-          Keyword.merge(opts, uuid_provided?: true)
-
-        _ ->
-          opts
-      end
-
-    {[Resource.Team], input, opts}
-  end
-
-  defp maybe_focus_search("user:" <> rest) do
-    {[Resource.User], rest, limit: 90}
-  end
-
-  defp maybe_focus_search(input) do
-    {@resources, input, limit: 30}
-  end
-end

extra/lib/plausible_web/live/customer_support/components/search_result.ex

@@ -1,105 +0,0 @@
-defmodule PlausibleWeb.CustomerSupport.Components.SearchResult do
-  @moduledoc """
-  Component responsible for rendering search result cards for customer support resources
-  """
-  use PlausibleWeb, :live_component
-
-  def favicon(assigns) do
-    ~H"""
-    <img src={"/favicon/sources/#{@domain}"} class={@class} />
-    """
-  end
-
-  def render_result(%{resource: %{type: "team"}} = assigns) do
-    ~H"""
-    <div class="flex-1 -mt-px w-full">
-      <div class="w-full flex items-center justify-between space-x-4">
-        <div class="w-5 h-5 rounded-full bg-blue-500 flex items-center justify-center">
-          <span class="text-white text-xs font-bold">T</span>
-        </div>
-        <h3
-          class="text-gray-900 font-medium text-lg truncate dark:text-gray-100"
-          style="width: calc(100% - 4rem)"
-        >
-          {@resource.object.name}
-        </h3>
-
-        <span class="inline-flex items-center px-2 py-0.5 rounded text-xs font-medium bg-blue-100 text-blue-800">
-          Team
-        </span>
-        <span
-          :if={@resource.object.subscription}
-          class="inline-flex items-center px-2 py-0.5 rounded text-xs font-medium bg-green-100 text-green-800"
-        >
-          $
-        </span>
-      </div>
-
-      <hr class="mt-4 mb-4 flex-grow border-t border-gray-200 dark:border-gray-600" />
-      <div class="text-sm truncate">
-        Team identifier:
-        <code class="font-mono">{@resource.object.identifier |> String.slice(0, 8)}</code>
-        <br />
-        Owned by: {@resource.object.owners
-        |> Enum.map(& &1.name)
-        |> Enum.join(", ")}
-      </div>
-    </div>
-    """
-  end
-
-  def render_result(%{resource: %{type: "user"}} = assigns) do
-    ~H"""
-    <div class="flex-1 -mt-px w-full">
-      <div class="w-full flex items-center justify-between space-x-4">
-        <img src={Plausible.Auth.User.profile_img_url(@resource.object)} class="h-5 w-5 rounded-full" />
-        <h3
-          class="text-gray-900 font-medium text-lg truncate dark:text-gray-100"
-          style="width: calc(100% - 4rem)"
-        >
-          {@resource.object.name}
-        </h3>
-
-        <span class="inline-flex items-center px-2 py-0.5 rounded text-xs font-medium bg-red-100 text-red-800">
-          User
-        </span>
-      </div>
-
-      <hr class="mt-4 mb-4 flex-grow border-t border-gray-200 dark:border-gray-600" />
-      <div class="text-sm truncate">
-        {@resource.object.name} &lt;{@resource.object.email}&gt; <br />
-        Owns {length(@resource.object.owned_teams)} team(s)
-      </div>
-    </div>
-    """
-  end
-
-  def render_result(%{resource: %{type: "site"}} = assigns) do
-    ~H"""
-    <div class="flex-1 -mt-px w-full">
-      <div class="w-full flex items-center justify-between space-x-4">
-        <.favicon class="w-5" domain={@resource.object.domain} />
-        <h3
-          class="text-gray-900 font-medium text-lg truncate dark:text-gray-100"
-          style="width: calc(100% - 4rem)"
-        >
-          {@resource.object.domain}
-        </h3>
-
-        <span class="inline-flex items-center px-2 py-0.5 rounded text-xs font-medium bg-green-100 text-green-800">
-          Site
-        </span>
-      </div>
-
-      <hr class="mt-4 mb-4 flex-grow border-t border-gray-200 dark:border-gray-600" />
-      <div class="text-sm truncate">
-        Part of <strong>{@resource.object.team.name}</strong>
-        <br />
-        owned by {@resource.object.team.owners
-        |> Enum.map(& &1.name)
-        |> Enum.join(", ")}
-      </div>
-    </div>
-    """
-  end
-end

extra/lib/plausible_web/live/customer_support/live.ex

@@ -1,133 +0,0 @@
-defmodule PlausibleWeb.CustomerSupport.Live do
-  @moduledoc """
-  Shared module providing common LiveView functionality for Customer Support.
-
-  Provides:
-  - Standard mount/3 and handle_info/2 implementations
-  - Tab navigation components and routing utilities  
-  - Common aliases and imports for Customer Support LiveViews
-  - Convenience API for flashes and redirects
-  """
-
-  defmacro __using__(_opts) do
-    quote do
-      use PlausibleWeb, :live_view
-
-      alias Plausible.CustomerSupport.Resource
-      alias PlausibleWeb.CustomerSupport.Components.Layout
-      import PlausibleWeb.CustomerSupport.Live
-      import PlausibleWeb.Components.Generic
-      alias PlausibleWeb.Router.Helpers, as: Routes
-
-      def mount(_params, _session, socket) do
-        {:ok, socket}
-      end
-
-      def handle_info({:success, msg}, socket) do
-        {:noreply, put_flash(socket, :success, msg)}
-      end
-
-      def handle_info({:error, msg}, socket) do
-        {:noreply, put_flash(socket, :error, msg)}
-      end
-
-      def handle_info({:navigate, path, success_msg}, socket) do
-        socket = if success_msg, do: put_flash(socket, :success, success_msg), else: socket
-        {:noreply, push_navigate(socket, to: path)}
-      end
-
-      def handle_params(%{"id" => _id} = params, _uri, socket) do
-        handle_params(Map.put(params, "tab", "overview"), nil, socket)
-      end
-
-      defoverridable mount: 3, handle_info: 2, handle_params: 3
-    end
-  end
-
-  @spec success(String.t()) :: :ok
-  def success(msg) do
-    send(self(), {:success, msg})
-  end
-
-  @spec failure(String.t()) :: :ok
-  def failure(msg) do
-    send(self(), {:error, msg})
-  end
-
-  @spec navigate_with_success(String.t(), String.t()) :: :ok
-  def navigate_with_success(path, msg) do
-    send(self(), {:navigate, path, msg})
-  end
-
-  use Phoenix.Component
-  import Phoenix.LiveView
-
-  attr :to, :string, required: true
-  attr :tab, :string, required: true
-  slot :inner_block, required: true
-
-  def tab(assigns) do
-    current_class = "text-gray-900 dark:text-gray-100"
-
-    inactive_class =
-      "text-gray-500 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-200"
-
-    assigns =
-      assign(
-        assigns,
-        :link_class,
-        if(assigns.to == assigns.tab, do: current_class, else: inactive_class)
-      )
-
-    ~H"""
-    <.link
-      patch={"?tab=#{@to}"}
-      class={[
-        @link_class,
-        "group relative min-w-0 flex-1 overflow-hidden bg-white dark:bg-gray-800 py-4 px-6 text-center text-sm font-medium hover:bg-gray-50 dark:hover:bg-gray-750 focus:z-10 first:rounded-l-lg last:rounded-r-lg"
-      ]}
-    >
-      {render_slot(@inner_block)}
-    </.link>
-    """
-  end
-
-  attr :tab, :string, required: true
-  attr :extra_classes, :string, default: ""
-  slot :tabs, required: true
-
-  def tab_navigation(assigns) do
-    ~H"""
-    <div class="mt-4">
-      <div class="hidden sm:block">
-        <nav
-          class={[
-            "isolate flex divide-x dark:divide-gray-900 divide-gray-200 rounded-lg shadow dark:shadow-1",
-            @extra_classes
-          ]}
-          aria-label="Tabs"
-        >
-          {render_slot(@tabs)}
-        </nav>
-      </div>
-    </div>
-    """
-  end
-
-  def go_to_tab(socket, tab, params, resource_key, component) do
-    tab_params = Map.drop(params, ["id", "tab"])
-    resource = Map.get(socket.assigns, resource_key)
-
-    update_params = [
-      id: "#{resource_key}-#{resource.id}-#{tab}",
-      tab: tab,
-      tab_params: tab_params
-    ]
-
-    update_params = Keyword.put(update_params, resource_key, resource)
-
-    send_update(component, update_params)
-
-    socket
-  end
-end

extra/lib/plausible_web/live/customer_support/site.ex

@@ -1,115 +0,0 @@
-defmodule PlausibleWeb.Live.CustomerSupport.Site do
-  @moduledoc """
-  Site coordinator LiveView for Customer Support interface.
-
-  Manages tab-based navigation and delegates rendering to specialized 
-  components: Overview, People, and Rescue Zone.
-  """
-  use PlausibleWeb.CustomerSupport.Live
-
-  alias PlausibleWeb.CustomerSupport.Site.Components.{
-    Overview,
-    People,
-    RescueZone
-  }
-
-  def favicon(assigns) do
-    ~H"""
-    <img src={"/favicon/sources/#{@domain}"} class={@class} />
-    """
-  end
-
-  def handle_params(%{"id" => site_id} = params, _uri, socket) do
-    tab = params["tab"] || "overview"
-    site = Resource.Site.get(site_id)
-
-    if site do
-      socket =
-        socket
-        |> assign(:site, site)
-        |> assign(:tab, tab)
-
-      {:noreply, go_to_tab(socket, tab, params, :site, tab_component(tab))}
-    else
-      {:noreply, redirect(socket, to: Routes.customer_support_path(socket, :index))}
-    end
-  end
-
-  def render(assigns) do
-    ~H"""
-    <Layout.layout show_search={false} flash={@flash}>
-      <.site_header site={@site} />
-      <.site_tab_navigation site={@site} tab={@tab} />
-
-      <.live_component
-        module={tab_component(@tab)}
-        site={@site}
-        tab={@tab}
-        id={"site-#{@site.id}-#{@tab}"}
-      />
-    </Layout.layout>
-    """
-  end
-
-  defp site_header(assigns) do
-    ~H"""
-    <div class="flex items-center">
-      <div class="rounded-full p-1 mr-4">
-        <.favicon class="w-8" domain={@site.domain} />
-      </div>
-      <div>
-        <p class="text-xl font-bold sm:text-2xl">
-          {@site.domain}
-          <span
-            :if={
-              @site.ingest_rate_limit_threshold &&
-                @site.ingest_rate_limit_threshold < @site.ingest_rate_limit_scale_seconds
-            }
-            class="inline-flex items-center px-2 py-0.5 rounded text-xs font-medium bg-red-100 text-red-800"
-          >
-            Rejecting traffic
-          </span>
-
-          <span
-            :if={@site.ingest_rate_limit_threshold == 0}
-            class="inline-flex items-center px-2 py-0.5 rounded text-xs font-medium bg-red-100 text-red-800"
-          >
-            Traffic blocked
-          </span>
-        </p>
-        <p class="text-sm font-medium">
-          Timezone: {@site.timezone}
-        </p>
-        <p class="text-sm font-medium">
-          Team:
-          <.styled_link patch={
-            Routes.customer_support_team_path(PlausibleWeb.Endpoint, :show, @site.team.id)
-          }>
-            {@site.team.name}
-          </.styled_link>
-        </p>
-        <p class="text-sm font-medium">
-          <span :if={@site.domain_changed_from}>(previously: {@site.domain_changed_from})</span>
-        </p>
-      </div>
-    </div>
-    """
-  end
-
-  defp site_tab_navigation(assigns) do
-    ~H"""
-    <.tab_navigation tab={@tab}>
-      <:tabs>
-        <.tab to="overview" tab={@tab}>Overview</.tab>
-        <.tab to="people" tab={@tab}>People</.tab>
-        <.tab to="rescue-zone" tab={@tab}>Rescue Zone</.tab>
-      </:tabs>
-    </.tab_navigation>
-    """
-  end
-
-  defp tab_component("overview"), do: Overview
-  defp tab_component("people"), do: People
-  defp tab_component("rescue-zone"), do: RescueZone
-  defp tab_component(_), do: Overview
-end

extra/lib/plausible_web/live/customer_support/site/components/overview.ex

@@ -1,104 +0,0 @@
-defmodule PlausibleWeb.CustomerSupport.Site.Components.Overview do
-  @moduledoc """
-  Site overview component - handles site settings and management
-  """
-  use PlausibleWeb, :live_component
-  import PlausibleWeb.CustomerSupport.Live
-
-  def update(%{site: site}, socket) do
-    changeset = Plausible.Site.crm_changeset(site, %{})
-    form = to_form(changeset)
-    {:ok, assign(socket, site: site, form: form)}
-  end
-
-  def render(assigns) do
-    ~H"""
-    <div class="mt-8">
-      <.form :let={f} for={@form} phx-target={@myself} phx-submit="save-site">
-        <div class="flex justify-center items-center gap-x-8 pb-8 mb-8 border-b border-gray-200 dark:border-gray-700 w-full text-sm text-center">
-          <span>Quick links:</span>
-
-          <.styled_link
-            new_tab={true}
-            href={Routes.stats_path(PlausibleWeb.Endpoint, :stats, @site.domain, [])}
-          >
-            Dashboard
-          </.styled_link>
-
-          <.styled_link
-            new_tab={true}
-            href={Routes.site_path(PlausibleWeb.Endpoint, :settings_general, @site.domain, [])}
-          >
-            Settings
-          </.styled_link>
-
-          <.styled_link
-            new_tab={true}
-            href={"https://plausible.grafana.net/d/BClBG5b4k/ingest-counters-per-domain?orgId=1&from=now-24h&to=now&timezone=browser&var-domain=#{@site.domain}&refresh=10s"}
-          >
-            Ingest Overview
-          </.styled_link>
-        </div>
-
-        <.input
-          type="select"
-          field={f[:timezone]}
-          label="Timezone"
-          options={Plausible.Timezones.options()}
-        />
-        <.input type="checkbox" field={f[:public]} label="Public?" />
-        <.input type="datetime-local" field={f[:native_stats_start_at]} label="Native Stats Start At" />
-        <.input
-          type="text"
-          field={f[:ingest_rate_limit_threshold]}
-          label="Ingest Rate Limit Threshold"
-        />
-        <.input
-          type="text"
-          field={f[:ingest_rate_limit_scale_seconds]}
-          label="Ingest Rate Limit Scale Seconds"
-        />
-
-        <div class="flex justify-between">
-          <.button phx-target={@myself} type="submit">
-            Save
-          </.button>
-
-          <.button
-            phx-target={@myself}
-            phx-click="delete-site"
-            data-confirm="Are you sure you want to delete this site?"
-            theme="danger"
-          >
-            Delete Site
-          </.button>
-        </div>
-      </.form>
-    </div>
-    """
-  end
-
-  def handle_event("save-site", %{"site" => params}, socket) do
-    site = socket.assigns.site
-
-    case Plausible.Site.crm_changeset(site, params) |> Plausible.Repo.update() do
-      {:ok, updated_site} ->
-        form = Plausible.Site.crm_changeset(updated_site, %{}) |> to_form()
-        success("Site updated successfully")
-        {:noreply, assign(socket, site: updated_site, form: form)}
-
-      {:error, changeset} ->
-        form = changeset |> to_form()
-        failure("Failed to update site")
-        {:noreply, assign(socket, form: form)}
-    end
-  end
-
-  def handle_event("delete-site", _, socket) do
-    site = socket.assigns.site
-
-    {:ok, _} = Plausible.Site.Removal.run(site)
-    navigate_with_success(Routes.customer_support_path(socket, :index), "Site deleted")
-    {:noreply, socket}
-  end
-end

extra/lib/plausible_web/live/customer_support/site/components/people.ex

@@ -1,70 +0,0 @@
-defmodule PlausibleWeb.CustomerSupport.Site.Components.People do
-  @moduledoc """
-  Site people component - handles site memberships and invitations
-  """
-  use PlausibleWeb, :live_component
-
-  def update(%{site: site}, socket) do
-    people = Plausible.Sites.list_people(site)
-
-    people =
-      (people.invitations ++ people.memberships)
-      |> Enum.map(fn p ->
-        if Map.has_key?(p, :invitation_id) do
-          {:invitation, p.email, p.role}
-        else
-          {:membership, p.user, p.role}
-        end
-      end)
-
-    {:ok, assign(socket, site: site, people: people)}
-  end
-
-  def render(assigns) do
-    ~H"""
-    <div class="mt-8">
-      <.table rows={@people}>
-        <:thead>
-          <.th>User</.th>
-          <.th>Kind</.th>
-          <.th>Role</.th>
-        </:thead>
-        <:tbody :let={{kind, person, role}}>
-          <.td :if={kind == :membership}>
-            <.styled_link
-              class="flex items-center"
-              patch={Routes.customer_support_user_path(PlausibleWeb.Endpoint, :show, person.id)}
-            >
-              <img
-                src={Plausible.Auth.User.profile_img_url(person)}
-                class="w-4 rounded-full bg-gray-300 mr-2"
-              />
-              {person.name}
-            </.styled_link>
-          </.td>
-
-          <.td :if={kind == :invitation}>
-            <div class="flex items-center">
-              <img
-                src={Plausible.Auth.User.profile_img_url(person)}
-                class="w-4 rounded-full bg-gray-300 mr-2"
-              />
-              {person}
-            </div>
-          </.td>
-
-          <.td :if={kind == :membership}>
-            Membership
-          </.td>
-
-          <.td :if={kind == :invitation}>
-            Invitation
-          </.td>
-
-          <.td>{role}</.td>
-        </:tbody>
-      </.table>
-    </div>
-    """
-  end
-end

extra/lib/plausible_web/live/customer_support/site/components/rescue_zone.ex

@@ -1,89 +0,0 @@
-defmodule PlausibleWeb.CustomerSupport.Site.Components.RescueZone do
-  @moduledoc """
-  Site rescue zone component - handles site transfer functionality
-  """
-  use PlausibleWeb, :live_component
-  import PlausibleWeb.CustomerSupport.Live
-  import PlausibleWeb.Components.Generic
-  import Ecto.Query
-  alias Plausible.Repo
-  alias PlausibleWeb.Live.Components.ComboBox
-
-  def update(%{site: site}, socket) do
-    first_owner =
-      hd(Repo.preload(site, :owners).owners)
-
-    {:ok, assign(socket, site: site, first_owner: first_owner)}
-  end
-
-  def render(assigns) do
-    ~H"""
-    <div class="mt-8">
-      <h1 class="text-xs font-semibold">Transfer Site</h1>
-      <form class="mt-4 mb-8" phx-target={@myself} phx-submit="init-transfer">
-        <.label for="inviter_email">
-          Initiate transfer as
-        </.label>
-        <.live_component
-          id="inviter_email"
-          submit_name="inviter_email"
-          class={[
-            "mb-4"
-          ]}
-          module={ComboBox}
-          suggest_fun={fn input, _ -> search_email(input) end}
-          selected={{@first_owner.email, "#{@first_owner.name} <#{@first_owner.email}>"}}
-        />
-
-        <.label for="invitee_email">
-          Send transfer invitation to
-        </.label>
-        <.live_component
-          id="invitee_email"
-          submit_name="invitee_email"
-          module={ComboBox}
-          suggest_fun={fn input, _ -> search_email(input) end}
-          creatable
-        />
-        <.button phx-target={@myself} type="submit">
-          Initiate Site Transfer
-        </.button>
-      </form>
-    </div>
-    """
-  end
-
-  def handle_event("init-transfer", params, socket) do
-    inviter = Plausible.Repo.get_by!(Plausible.Auth.User, email: params["inviter_email"])
-
-    case Plausible.Teams.Invitations.InviteToSite.invite(
-           socket.assigns.site,
-           inviter,
-           params["invitee_email"],
-           :owner
-         ) do
-      {:ok, _transfer} ->
-        success("Transfer e-mail sent!")
-        {:noreply, socket}
-
-      error ->
-        failure("Transfer failed: #{inspect(error)}")
-        {:noreply, socket}
-    end
-  end
-
-  defp search_email(input) do
-    Repo.all(
-      from u in Plausible.Auth.User,
-        where: ilike(u.name, ^"%#{input}%") or ilike(u.email, ^"%#{input}%"),
-        limit: 20,
-        order_by: [
-          desc: fragment("?.name = ?", u, ^input),
-          desc: fragment("?.email = ?", u, ^input),
-          asc: u.name
-        ],
-        select: {u.email, u.name}
-    )
-    |> Enum.map(fn {email, name} -> {email, "#{name} <#{email}>"} end)
-  end
-end

extra/lib/plausible_web/live/customer_support/team.ex

@@ -1,381 +0,0 @@
-defmodule PlausibleWeb.Live.CustomerSupport.Team do
-  @moduledoc """
-  Team coordinator LiveView for Customer Support interface.
-
-  Manages tab-based navigation and delegates rendering to specialized
-  components: Overview, Members, Sites, Billing, SSO, and Audit.
-  """
-  use PlausibleWeb.CustomerSupport.Live
-
-  alias PlausibleWeb.CustomerSupport.Team.Components.{
-    Overview,
-    Members,
-    Sites,
-    ConsolidatedViews,
-    Billing,
-    SSO,
-    Audit
-  }
-
-  require Plausible.Billing.Subscription.Status
-
-  def handle_params(%{"id" => id} = params, _uri, socket) do
-    tab = params["tab"] || "overview"
-    team_id = String.to_integer(id)
-    team = Resource.Team.get(team_id)
-
-    if team do
-      tab_params = Map.drop(params, ["id", "tab"])
-
-      socket =
-        socket
-        |> assign(:team, team)
-        |> assign(:tab, tab)
-        |> assign(:tab_params, tab_params)
-
-      {:noreply, go_to_tab(socket, tab, params, :team, tab_component(tab))}
-    else
-      {:noreply, redirect(socket, to: Routes.customer_support_path(socket, :index))}
-    end
-  end
-
-  def handle_event("unlock", _, socket) do
-    {:noreply, unlock_team(socket)}
-  end
-
-  def handle_event("lock", _, socket) do
-    {:noreply, lock_team(socket)}
-  end
-
-  def handle_event("refund-lock", _, socket) do
-    team = socket.assigns.team
-
-    {:ok, team} =
-      Plausible.Repo.transaction(fn ->
-        yesterday = Date.shift(Date.utc_today(), day: -1)
-        Plausible.Billing.SiteLocker.set_lock_status_for(team, true)
-
-        Plausible.Repo.update!(
-          Plausible.Billing.Subscription.changeset(team.subscription, %{next_bill_date: yesterday})
-        )
-
-        Resource.Team.get(team.id)
-      end)
-
-    {:noreply, assign(socket, team: team)}
-  end
-
-  def render(assigns) do
-    team = assigns.team
-
-    usage = Plausible.Teams.Billing.quota_usage(team, with_features: true)
-
-    limits = %{
-      monthly_pageviews: Plausible.Teams.Billing.monthly_pageview_limit(team),
-      sites: Plausible.Teams.Billing.site_limit(team),
-      team_members: Plausible.Teams.Billing.team_member_limit(team)
-    }
-
-    assigns = assign(assigns, usage: usage, limits: limits)
-
-    ~H"""
-    <Layout.layout show_search={false} flash={@flash}>
-      <.team_header team={@team} />
-      <.team_tab_navigation team={@team} tab={@tab} limits={@limits} usage={@usage} />
-      <.subscription_bar team={@team} />
-
-      <.live_component
-        module={tab_component(@tab)}
-        team={@team}
-        tab={@tab}
-        tab_params={@tab_params}
-        id={"team-#{@team.id}-#{@tab}"}
-      />
-    </Layout.layout>
-    """
-  end
-
-  defp team_header(assigns) do
-    ~H"""
-    <div>
-      <div class="sm:flex sm:items-center sm:justify-between">
-        <div class="sm:flex sm:space-x-5">
-          <div class="shrink-0">
-            <div class={[
-              team_bg(@team.identifier),
-              "rounded-full p-1 flex items-center justify-center"
-            ]}>
-              <Heroicons.user_group class="h-14 w-14 text-white dark:text-gray-300" />
-            </div>
-          </div>
-          <div class="mt-4 text-center sm:mt-0 sm:pt-1 sm:text-left">
-            <p class="text-xl font-bold dark:text-gray-300 text-gray-900 sm:text-2xl">
-              {@team.name}
-            </p>
-            <p class="text-sm font-medium dark:text-gray-500">
-              <span :if={@team.setup_complete}>Set up at {@team.setup_at}</span>
-              <span :if={!@team.setup_complete}>Not set up yet</span>
-            </p>
-          </div>
-        </div>
-
-        <div class="mt-5 flex justify-center sm:mt-0">
-          <.input_with_clipboard
-            id="team-identifier"
-            name="team-identifier"
-            label="Team Identifier"
-            value={@team.identifier}
-            onfocus="this.value = this.value;"
-          />
-        </div>
-      </div>
-    </div>
-    """
-  end
-
-  defp team_tab_navigation(assigns) do
-    ~H"""
-    <.tab_navigation tab={@tab}>
-      <:tabs>
-        <.tab to="overview" tab={@tab}>Overview</.tab>
-        <.tab to="members" tab={@tab}>
-          Members ({number_format(@usage.team_members)}/{number_format(@limits.team_members)})
-        </.tab>
-        <.tab to="sites" tab={@tab}>
-          Sites ({number_format(@usage.sites)}/{number_format(@limits.sites)})
-        </.tab>
-        <.tab :if={Plausible.Teams.setup?(@team)} to="consolidated_views" tab={@tab}>
-          Consolidated Views
-        </.tab>
-        <.tab :if={has_sso_integration?(@team)} to="sso" tab={@tab}>SSO</.tab>
-        <.tab to="billing" tab={@tab}>Billing</.tab>
-        <.tab to="audit" tab={@tab}>Audit</.tab>
-      </:tabs>
-    </.tab_navigation>
-    """
-  end
-
-  defp subscription_bar(assigns) do
-    ~H"""
-    <div class="grid grid-cols-1 divide-y border-t sm:grid-cols-3 sm:divide-x sm:divide-y-0 dark:bg-gray-850 text-gray-900 dark:text-gray-400 dark:divide-gray-800 dark:border-gray-600">
-      <div class="px-6 py-5 text-center text-sm font-medium">
-        <span>
-          <strong>Subscription status</strong> <br />{subscription_status(@team)}
-          <div :if={
-            @team.subscription &&
-              @team.subscription.status == Plausible.Billing.Subscription.Status.deleted() &&
-              !@team.grace_period
-          }>
-            <span class="flex items-center gap-x-8 justify-center mt-1">
-              <div :if={not Plausible.Teams.locked?(@team)}>
-                <Heroicons.lock_open solid class="inline stroke-2 w-4 h-4 text-red-400 mr-1" />
-                <.styled_link
-                  phx-click="refund-lock"
-                  data-confirm="Are you sure you want to lock? The only way to unlock, is for the user to resubscribe."
-                >
-                  Refund Lock
-                </.styled_link>
-              </div>
-
-              <div :if={Plausible.Teams.locked?(@team)}>
-                <Heroicons.lock_closed solid class="inline stroke-2 w-4 h-4 text-red-400 mr-1" />
-                Locked
-              </div>
-            </span>
-          </div>
-        </span>
-      </div>
-      <div class="px-6 py-5 text-center text-sm font-medium">
-        <span>
-          <strong>Subscription plan</strong> <br />{subscription_plan(@team)}
-        </span>
-      </div>
-      <div class="px-6 py-5 text-center text-sm font-medium">
-        <span>
-          <strong>Grace Period</strong> <br />{grace_period_status(@team)}
-
-          <div :if={@team.grace_period}>
-            <span class="flex items-center gap-x-8 justify-center mt-1">
-              <div>
-                <Heroicons.lock_open solid class="inline stroke-2 w-4 h-4 text-red-400 mr-1" />
-                <.styled_link phx-click="unlock">Unlock</.styled_link>
-              </div>
-
-              <div>
-                <Heroicons.lock_closed solid class="inline stroke-2 w-4 h-4 text-red-400 mr-1" />
-                <.styled_link phx-click="lock">Lock</.styled_link>
-              </div>
-            </span>
-          </div>
-        </span>
-      </div>
-    </div>
-    """
-  end
-
-  defp tab_component("overview"), do: Overview
-  defp tab_component("members"), do: Members
-  defp tab_component("sites"), do: Sites
-  defp tab_component("consolidated_views"), do: ConsolidatedViews
-  defp tab_component("billing"), do: Billing
-  defp tab_component("sso"), do: SSO
-  defp tab_component("audit"), do: Audit
-  defp tab_component(_), do: Overview
-
-  defp has_sso_integration?(team) do
-    case Plausible.Auth.SSO.get_integration_for(team) do
-      {:ok, _} -> true
-      {:error, :not_found} -> false
-    end
-  end
-
-  defp team_bg(term) do
-    list = [
-      "bg-blue-500",
-      "bg-blue-600",
-      "bg-blue-700",
-      "bg-blue-800",
-      "bg-cyan-500",
-      "bg-cyan-600",
-      "bg-cyan-700",
-      "bg-cyan-800",
-      "bg-red-500",
-      "bg-red-600",
-      "bg-red-700",
-      "bg-red-800",
-      "bg-green-500",
-      "bg-green-600",
-      "bg-green-700",
-      "bg-green-800",
-      "bg-yellow-500",
-      "bg-yellow-600",
-      "bg-yellow-700",
-      "bg-yellow-800",
-      "bg-orange-500",
-      "bg-orange-600",
-      "bg-orange-700",
-      "bg-orange-800",
-      "bg-purple-500",
-      "bg-purple-600",
-      "bg-purple-700",
-      "bg-purple-800",
-      "bg-gray-500",
-      "bg-gray-600",
-      "bg-gray-700",
-      "bg-gray-800",
-      "bg-emerald-500",
-      "bg-emerald-600",
-      "bg-emerald-700",
-      "bg-emerald-800"
-    ]
-
-    idx = :erlang.phash2(term, length(list))
-    Enum.at(list, idx)
-  end
-
-  defp subscription_status(team) do
-    cond do
-      team && team.subscription ->
-        status_str =
-          PlausibleWeb.Components.Billing.Helpers.present_subscription_status(
-            team.subscription.status
-          )
-
-        if team.subscription.paddle_subscription_id do
-          assigns = %{status_str: status_str, subscription: team.subscription}
-
-          ~H"""
-          <.styled_link new_tab={true} href={manage_url(@subscription)}>{@status_str}</.styled_link>
-          """
-        else
-          status_str
-        end
-
-      Plausible.Teams.on_trial?(team) ->
-        "On trial"
-
-      true ->
-        "Trial expired"
-    end
-  end
-
-  defp manage_url(%{paddle_subscription_id: paddle_id} = _subscription) do
-    Plausible.Billing.PaddleApi.vendors_domain() <>
-      "/subscriptions/customers/manage/" <> paddle_id
-  end
-
-  defp subscription_plan(team) do
-    subscription = team.subscription
-
-    if Plausible.Billing.Subscription.Status.active?(subscription) &&
-         subscription.paddle_subscription_id do
-      quota = PlausibleWeb.AuthView.subscription_quota(subscription)
-      interval = PlausibleWeb.AuthView.subscription_interval(subscription)
-
-      assigns = %{quota: quota, interval: interval, subscription: subscription}
-
-      ~H"""
-      <.styled_link new_tab={true} href={manage_url(@subscription)}>
-        {@quota} ({@interval})
-      </.styled_link>
-      """
-    else
-      "--"
-    end
-  end
-
-  defp grace_period_status(team) do
-    grace_period = team.grace_period
-
-    case grace_period do
-      nil ->
-        "--"
-
-      %{manual_lock: true, is_over: true} ->
-        "Manually locked"
-
-      %{manual_lock: true, is_over: false} ->
-        "Waiting for manual lock"
-
-      %{is_over: true} ->
-        "ended"
-
-      %{end_date: %Date{} = end_date} ->
-        days_left = Date.diff(end_date, Date.utc_today())
-        "#{days_left} days left"
-    end
-  end
-
-  defp lock_team(socket) do
-    if socket.assigns.team.grace_period do
-      team = Plausible.Teams.end_grace_period(socket.assigns.team)
-      Plausible.Billing.SiteLocker.set_lock_status_for(team, true)
-
-      put_live_flash(socket, :success, "Team locked. Grace period ended.")
-      assign(socket, team: team)
-    else
-      put_live_flash(socket, :error, "No grace period")
-      socket
-    end
-  end
-
-  defp unlock_team(socket) do
-    if socket.assigns.team.grace_period do
-      team = Plausible.Teams.remove_grace_period(socket.assigns.team)
-      Plausible.Billing.SiteLocker.set_lock_status_for(team, false)
-
-      put_live_flash(socket, :success, "Team unlocked. Grace period removed.")
-      assign(socket, team: team)
-    else
-      socket
-    end
-  end
-
-  defp number_format(unlimited) when unlimited in [-1, "unlimited", :unlimited] do
-    "unlimited"
-  end
-
-  defp number_format(input) do
-    PlausibleWeb.TextHelpers.number_format(input)
-  end
-end

extra/lib/plausible_web/live/customer_support/team/components/audit.ex

@@ -1,245 +0,0 @@
-defmodule PlausibleWeb.CustomerSupport.Team.Components.Audit do
-  @moduledoc """
-  Team audit component - handles audit log viewing
-  """
-  use PlausibleWeb, :live_component
-
-  def update(%{team: team, tab_params: tab_params}, socket) do
-    pagination_params = get_pagination_params(tab_params)
-    audit_page = Plausible.Audit.list_entries_paginated([team_id: team.id], pagination_params)
-
-    entries = process_audit_entries(audit_page.entries)
-    audit_page = %{audit_page | entries: entries}
-    current_limit = pagination_params["limit"]
-
-    {:ok,
-     assign(socket,
-       team: team,
-       audit_page: audit_page,
-       revealed_audit_entry_id: nil,
-       current_limit: current_limit
-     )}
-  end
-
-  def update(%{team: team}, socket) do
-    update(%{team: team, tab_params: %{}}, socket)
-  end
-
-  def render(assigns) do
-    ~H"""
-    <div class="mt-4 mb-4 text-gray-900 dark:text-gray-400 relative">
-      <div :if={Enum.empty?(@audit_page.entries)} class="flex justify-center items-center">
-        No audit logs yet
-      </div>
-
-      <div
-        :if={@revealed_audit_entry_id}
-        phx-target={@myself}
-        phx-window-keydown="reveal-audit-entry"
-        phx-key="escape"
-      >
-        <.input_with_clipboard
-          id="audit-entry-identifier"
-          name="audit-entry-identifier"
-          label="Audit Entry Identifier"
-          value={@revealed_audit_entry_id}
-        />
-        <div class="relative">
-          <.input
-            rows="16"
-            type="textarea"
-            id="audit-entry-change"
-            name="audit-entry-change"
-            value={
-              Jason.encode!(
-                Enum.find(@audit_page.entries, &(&1.id == @revealed_audit_entry_id)).change,
-                pretty: true
-              )
-            }
-          >
-          </.input>
-          <.styled_link
-            class="text-sm float-right"
-            onclick="var textarea = document.getElementById('audit-entry-change'); textarea.focus(); textarea.select(); document.execCommand('copy');"
-            href="#"
-          >
-            <div class="flex items-center absolute top-4 right-4 text-xs gap-x-1">
-              <Heroicons.document_duplicate class="h-4 w-4 text-indigo-700" /> COPY
-            </div>
-          </.styled_link>
-
-          <.styled_link
-            phx-click="reveal-audit-entry"
-            phx-target={@myself}
-            class="float-right pt-4 text-sm"
-          >
-            &larr; Return
-            <kbd class="rounded border border-gray-200 dark:border-gray-600 px-1.5 font-medium text-xs text-gray-400">
-              ESC
-            </kbd>
-          </.styled_link>
-        </div>
-      </div>
-
-      <.table :if={is_nil(@revealed_audit_entry_id)} rows={@audit_page.entries}>
-        <:thead>
-          <.th invisible></.th>
-          <.th invisible></.th>
-          <.th>Name</.th>
-          <.th>Entity</.th>
-          <.th>Actor</.th>
-          <.th invisible>Actions</.th>
-        </:thead>
-        <:tbody :let={entry}>
-          <.td>{Calendar.strftime(entry.datetime, "%Y-%m-%d")}</.td>
-          <.td>{Calendar.strftime(entry.datetime, "%H:%M:%S")}</.td>
-          <.td class="font-mono">{entry.name}</.td>
-          <.td truncate>
-            <.audit_entity entry={entry} />
-          </.td>
-          <.td :if={entry.actor_type == :system}>
-            <div class="flex items-center gap-x-1">
-              <Heroicons.cog_6_tooth class="size-4" /> SYSTEM
-            </div>
-          </.td>
-          <.td :if={entry.actor_type == :user} truncate>
-            <.audit_user user={entry.meta.user} />
-          </.td>
-
-          <.td actions>
-            <.edit_button
-              phx-click="reveal-audit-entry"
-              phx-value-id={entry.id}
-              phx-target={@myself}
-            />
-          </.td>
-        </:tbody>
-      </.table>
-
-      <div
-        :if={
-          is_nil(@revealed_audit_entry_id) &&
-            (@audit_page.metadata.before || @audit_page.metadata.after)
-        }
-        class="flex justify-between items-center mt-4"
-      >
-        <.button
-          :if={@audit_page.metadata.before}
-          id="prev-page"
-          phx-click="paginate-audit"
-          phx-value-before={@audit_page.metadata.before}
-          phx-value-limit={@current_limit}
-          phx-target={@myself}
-          theme="secondary"
-        >
-          &larr; Prev
-        </.button>
-        <div></div>
-        <.button
-          :if={@audit_page.metadata.after}
-          id="next-page"
-          phx-click="paginate-audit"
-          phx-value-after={@audit_page.metadata.after}
-          phx-value-limit={@current_limit}
-          phx-target={@myself}
-          theme="secondary"
-        >
-          Next &rarr;
-        </.button>
-      </div>
-    </div>
-    """
-  end
-
-  def handle_event("reveal-audit-entry", %{"id" => id}, socket) do
-    {:noreply, assign(socket, revealed_audit_entry_id: id)}
-  end
-
-  def handle_event("reveal-audit-entry", _, socket) do
-    {:noreply, assign(socket, revealed_audit_entry_id: nil)}
-  end
-
-  def handle_event("paginate-audit", params, socket) do
-    pagination_params = get_pagination_params(params)
-    team = socket.assigns.team
-
-    query_params = %{"tab" => "audit"} |> Map.merge(pagination_params)
-
-    {:noreply,
-     push_patch(socket,
-       to: Routes.customer_support_team_path(PlausibleWeb.Endpoint, :show, team.id, query_params)
-     )}
-  end
-
-  defp process_audit_entries(entries) do
-    Enum.map(entries, fn entry ->
-      meta = entry.meta
-
-      meta =
-        if entry.user_id && entry.user_id > 0 do
-          user = Plausible.Repo.get(Plausible.Auth.User, entry.user_id)
-          Map.put(meta, :user, user)
-        else
-          meta
-        end
-
-      meta =
-        if entry.entity == "Plausible.Auth.User" do
-          user = Plausible.Repo.get(Plausible.Auth.User, String.to_integer(entry.entity_id))
-          Map.put(meta, :entity, user)
-        else
-          meta
-        end
-
-      Map.put(entry, :meta, meta)
-    end)
-  end
-
-  attr :entry, Plausible.Audit.Entry
-
-  defp audit_entity(assigns) do
-    ~H"""
-    <%= if @entry.entity == "Plausible.Auth.User" do %>
-      <.audit_user user={@entry.meta.entity} />
-    <% else %>
-      {@entry.entity |> String.split(".") |> List.last()} #{String.slice(@entry.entity_id, 0, 8)}
-    <% end %>
-    """
-  end
-
-  attr :user, Plausible.Auth.User
-
-  defp audit_user(%{user: nil} = assigns) do
-    ~H"""
-    (N/A)
-    """
-  end
-
-  defp audit_user(assigns) do
-    ~H"""
-    <div class="flex items-center gap-x-1">
-      <img
-        class="w-4"
-        src={
-          Plausible.Auth.User.profile_img_url(%Plausible.Auth.User{
-            email: @user.email
-          })
-        }
-      />
-
-      <.styled_link
-        patch={Routes.customer_support_user_path(PlausibleWeb.Endpoint, :show, @user.id)}
-        class="cursor-pointer flex block items-center"
-      >
-        {@user.name}
-      </.styled_link>
-    </div>
-    """
-  end
-
-  defp get_pagination_params(params) do
-    params
-    |> Map.take(["after", "before", "limit"])
-    |> Map.put_new("limit", 15)
-  end
-end

extra/lib/plausible_web/live/customer_support/team/components/billing.ex

@@ -1,461 +0,0 @@
-defmodule PlausibleWeb.CustomerSupport.Team.Components.Billing do
-  @moduledoc """
-  Team billing component - handles subscription and custom plans
-  """
-  use PlausibleWeb, :live_component
-  import PlausibleWeb.CustomerSupport.Live
-
-  alias Plausible.Billing.EnterprisePlan
-  alias Plausible.Billing.Plans
-  alias Plausible.Teams
-  import Ecto.Query, only: [from: 2]
-  import PlausibleWeb.Components.Generic
-
-  def update(%{team: team}, socket) do
-    usage = Teams.Billing.quota_usage(team, with_features: true)
-
-    limits = %{
-      monthly_pageviews: Teams.Billing.monthly_pageview_limit(team),
-      sites: Teams.Billing.site_limit(team),
-      team_members: Teams.Billing.team_member_limit(team)
-    }
-
-    plans = get_plans(team.id)
-    plan = Plans.get_subscription_plan(team.subscription)
-
-    attrs = get_plan_attrs(plan)
-    plan_form = to_form(EnterprisePlan.changeset(%EnterprisePlan{}, attrs))
-
-    {:ok,
-     assign(socket,
-       team: team,
-       usage: usage,
-       limits: limits,
-       plan: plan,
-       plans: plans,
-       plan_form: plan_form,
-       show_plan_form?: false,
-       editing_plan: nil,
-       cost_estimate: 0
-     )}
-  end
-
-  def render(assigns) do
-    ~H"""
-    <div>
-      <script type="text/javascript">
-        const featureChangeCallback = function(e) {
-          const value = e.target.value
-          const checked = e.target.checked
-          const form = e.target.closest('form')
-
-          if (value === 'sites_api' && checked) {
-            form.querySelector('input[value=stats_api]').checked = true
-          } else if (value === 'stats_api' && !checked) {
-            form.querySelector('input[value=sites_api]').checked = false
-          }
-        }
-      </script>
-
-      <div class="flex">
-        <.button
-          :if={!@show_plan_form?}
-          id="new-custom-plan"
-          phx-click="show-plan-form"
-          phx-target={@myself}
-          class="ml-auto"
-        >
-          New Custom Plan
-        </.button>
-      </div>
-
-      <div class="mt-4 mb-4 text-gray-900 dark:text-gray-400">
-        <h1 class="text-xs font-semibold">Usage</h1>
-        <.table rows={monthly_pageviews_usage(@usage.monthly_pageviews, @limits.monthly_pageviews)}>
-          <:thead>
-            <.th invisible>Cycle</.th>
-            <.th invisible>Dates</.th>
-            <.th>Total</.th>
-            <.th>Limit</.th>
-          </:thead>
-          <:tbody :let={{cycle, date, total, limit}}>
-            <.td>{cycle}</.td>
-            <.td>{date}</.td>
-            <.td>
-              <span class={if total > limit, do: "text-red-600"}>
-                {number_format(total)}
-              </span>
-            </.td>
-            <.td>{number_format(limit)}</.td>
-          </:tbody>
-        </.table>
-
-        <p :if={@usage.features != []} class="mt-6 mb-4">
-          <h1 class="text-xs font-semibold">Features Used</h1>
-          <span class="text-sm">
-            {@usage.features |> Enum.map(& &1.display_name()) |> Enum.join(", ")}
-          </span>
-        </p>
-
-        <h1 :if={!@show_plan_form? and @plans != []} class="mt-8 text-xs font-semibold">
-          Custom Plans
-        </h1>
-        <.table :if={!@show_plan_form?} rows={@plans}>
-          <:thead>
-            <.th invisible>Interval</.th>
-            <.th>Paddle Plan ID</.th>
-            <.th>Limits</.th>
-            <.th>Features</.th>
-            <.th invisible>Actions</.th>
-          </:thead>
-          <:tbody :let={plan}>
-            <.td class="align-top">
-              {plan.billing_interval}
-            </.td>
-            <.td class="align-top" data-test-id={"plan-entry-#{plan.paddle_plan_id}"}>
-              {plan.paddle_plan_id}
-
-              <span
-                :if={current_plan?(@team, plan.paddle_plan_id)}
-                class="inline-flex items-center px-2 py-0.5 rounded text-xs font-xs bg-red-100 text-red-800"
-              >
-                CURRENT
-              </span>
-            </.td>
-            <.td max_width="max-w-40">
-              <.table rows={[
-                {"Pageviews", number_format(plan.monthly_pageview_limit)},
-                {"Sites", number_format(plan.site_limit)},
-                {"Members", number_format(plan.team_member_limit)},
-                {"API Requests", number_format(plan.hourly_api_request_limit)}
-              ]}>
-                <:tbody :let={{label, value}}>
-                  <.td>{label}</.td>
-                  <.td>{value}</.td>
-                </:tbody>
-              </.table>
-            </.td>
-            <.td class="align-top">
-              <span :for={feat <- plan.features}>{feat.display_name()}<br /></span>
-            </.td>
-            <.td class="align-top">
-              <.edit_button phx-click="edit-plan" phx-value-id={plan.id} phx-target={@myself} />
-              <.delete_button
-                :if={not current_plan?(@team, plan.paddle_plan_id)}
-                data-test-id={"delete-plan-#{plan.paddle_plan_id}"}
-                data-confirm="Are you sure you want to delete this plan?"
-                phx-click="delete-plan"
-                phx-value-id={plan.id}
-                phx-target={@myself}
-              />
-            </.td>
-          </:tbody>
-        </.table>
-
-        <.form
-          :let={f}
-          :if={@show_plan_form?}
-          for={@plan_form}
-          id="save-plan"
-          phx-submit={if @editing_plan, do: "update-plan", else: "save-plan"}
-          phx-target={@myself}
-          phx-change="estimate-cost"
-        >
-          <.input field={f[:paddle_plan_id]} label="Paddle Plan ID" autocomplete="off" />
-          <.input
-            type="select"
-            options={["monthly", "yearly"]}
-            field={f[:billing_interval]}
-            label="Billing Interval"
-            autocomplete="off"
-          />
-
-          <div class="flex items-center gap-x-4">
-            <.input
-              field={f[:monthly_pageview_limit]}
-              label="Monthly Pageview Limit"
-              autocomplete="off"
-              width="w-[500]"
-            />
-            <.preview for={f[:monthly_pageview_limit]} />
-          </div>
-
-          <div class="flex items-center gap-x-4">
-            <.input width="w-[500]" field={f[:site_limit]} label="Site Limit" autocomplete="off" />
-            <.preview for={f[:site_limit]} />
-          </div>
-
-          <div class="flex items-center gap-x-4">
-            <.input
-              field={f[:team_member_limit]}
-              label="Team Member Limit"
-              autocomplete="off"
-              width="w-[500]"
-            />
-            <.preview for={f[:team_member_limit]} />
-          </div>
-
-          <div class="flex items-center gap-x-4">
-            <.input
-              field={f[:hourly_api_request_limit]}
-              label="Hourly API Request Limit"
-              autocomplete="off"
-              width="w-[500]"
-            />
-            <.preview for={f[:hourly_api_request_limit]} />
-          </div>
-
-          <.input
-            :for={
-              mod <-
-                Plausible.Billing.Feature.list()
-                |> Enum.sort_by(fn item -> if item.name() == :stats_api, do: 0, else: 1 end)
-            }
-            :if={mod not in Teams.Billing.free_features()}
-            x-on:change="featureChangeCallback(event)"
-            type="checkbox"
-            value={mod in (f.source.changes[:features] || f.source.data.features || [])}
-            name={"#{f.name}[features[]][#{mod.name()}]"}
-            label={mod.display_name()}
-          />
-
-          <div class="mt-8 flex align-center gap-x-4">
-            <.input
-              type="checkbox"
-              field={f[:managed_proxy_price_modifier]}
-              label="Managed proxy"
-            />
-          </div>
-
-          <div class="mt-8 flex align-center gap-x-4">
-            <.input_with_clipboard
-              id="cost-estimate"
-              name="cost-estimate"
-              label={"#{(f[:billing_interval].value || "monthly")} cost estimate"}
-              value={@cost_estimate}
-            />
-
-            <.button theme="secondary" phx-click="hide-plan-form" phx-target={@myself}>
-              Cancel
-            </.button>
-
-            <.button type="submit">
-              {if @editing_plan, do: "Update Plan", else: "Save Custom Plan"}
-            </.button>
-          </div>
-        </.form>
-      </div>
-    </div>
-    """
-  end
-
-  def handle_event("show-plan-form", _, socket) do
-    {:noreply, assign(socket, show_plan_form?: true, editing_plan: nil)}
-  end
-
-  def handle_event("edit-plan", %{"id" => plan_id}, socket) do
-    {plan_id, _} = Integer.parse(plan_id)
-    plan = Enum.find(socket.assigns.plans, &(&1.id == plan_id))
-
-    if plan do
-      plan_form = to_form(EnterprisePlan.changeset(plan, %{}))
-      {:noreply, assign(socket, show_plan_form?: true, editing_plan: plan, plan_form: plan_form)}
-    else
-      {:noreply, socket}
-    end
-  end
-
-  def handle_event("delete-plan", %{"id" => plan_id}, socket) do
-    plan = Plausible.Repo.get(EnterprisePlan, plan_id)
-
-    if not current_plan?(socket.assigns.team, plan.paddle_plan_id),
-      do: Plausible.Repo.delete(plan)
-
-    plans = get_plans(socket.assigns.team.id)
-    {:noreply, assign(socket, plans: plans)}
-  end
-
-  def handle_event("hide-plan-form", _, socket) do
-    {:noreply, assign(socket, show_plan_form?: false, editing_plan: nil)}
-  end
-
-  def handle_event("estimate-cost", %{"enterprise_plan" => params}, socket) do
-    params = update_features_to_list(params)
-
-    form = to_form(EnterprisePlan.changeset(%EnterprisePlan{}, params))
-
-    params = sanitize_params(params)
-
-    cost_estimate =
-      Plausible.CustomerSupport.EnterprisePlan.estimate(
-        billing_interval: params["billing_interval"],
-        pageviews_per_month: get_int_param(params, "monthly_pageview_limit"),
-        sites_limit: get_int_param(params, "site_limit"),
-        team_members_limit: get_int_param(params, "team_member_limit"),
-        api_calls_limit: get_int_param(params, "hourly_api_request_limit"),
-        features: params["features"],
-        managed_proxy_price_modifier: params["managed_proxy_price_modifier"] == "true"
-      )
-
-    {:noreply, assign(socket, cost_estimate: cost_estimate, plan_form: form)}
-  end
-
-  def handle_event("save-plan", %{"enterprise_plan" => params}, socket) do
-    params = params |> update_features_to_list() |> sanitize_params()
-    changeset = EnterprisePlan.changeset(%EnterprisePlan{team_id: socket.assigns.team.id}, params)
-
-    case Plausible.Repo.insert(changeset) do
-      {:ok, _plan} ->
-        success("Plan saved")
-        plans = get_plans(socket.assigns.team.id)
-
-        {:noreply,
-         assign(socket,
-           plans: plans,
-           plan_form: to_form(changeset),
-           show_plan_form?: false,
-           editing_plan: nil
-         )}
-
-      {:error, changeset} ->
-        failure("Error saving plan: #{inspect(changeset.errors)}")
-        {:noreply, assign(socket, plan_form: to_form(changeset))}
-    end
-  end
-
-  def handle_event("update-plan", %{"enterprise_plan" => params}, socket) do
-    params = params |> update_features_to_list() |> sanitize_params()
-    changeset = EnterprisePlan.changeset(socket.assigns.editing_plan, params)
-
-    case Plausible.Repo.update(changeset) do
-      {:ok, _plan} ->
-        success("Plan updated")
-        plans = get_plans(socket.assigns.team.id)
-
-        {:noreply,
-         assign(socket,
-           plans: plans,
-           plan_form: to_form(changeset),
-           show_plan_form?: false,
-           editing_plan: nil
-         )}
-
-      {:error, changeset} ->
-        failure("Error updating plan: #{inspect(changeset.errors)}")
-        {:noreply, assign(socket, plan_form: to_form(changeset))}
-    end
-  end
-
-  # Helper functions
-  defp get_plan_attrs(plan) when is_map(plan) do
-    Map.take(plan, [
-      :billing_interval,
-      :monthly_pageview_limit,
-      :site_limit,
-      :team_member_limit,
-      :hourly_api_request_limit,
-      :features
-    ])
-    |> Map.update(:features, [], fn features ->
-      Enum.map(features, &to_string(&1.name()))
-    end)
-  end
-
-  defp get_plan_attrs(_) do
-    %{
-      monthly_pageview_limit: 10_000,
-      hourly_api_request_limit: 600,
-      site_limit: 10,
-      team_member_limit: 10,
-      features: Plausible.Billing.Feature.list() -- [Plausible.Billing.Feature.SSO]
-    }
-  end
-
-  defp monthly_pageviews_usage(usage, limit) do
-    usage
-    |> Enum.sort_by(fn {_cycle, usage} -> usage.date_range.first end, :desc)
-    |> Enum.map(fn {cycle, usage} ->
-      {cycle, PlausibleWeb.TextHelpers.format_date_range(usage.date_range), usage.total, limit}
-    end)
-  end
-
-  defp get_plans(team_id) do
-    Plausible.Repo.all(
-      from ep in EnterprisePlan,
-        where: ep.team_id == ^team_id,
-        order_by: [desc: :id]
-    )
-  end
-
-  defp number_format(unlimited) when unlimited in [-1, "unlimited", :unlimited] do
-    "unlimited"
-  end
-
-  defp number_format(input) do
-    PlausibleWeb.TextHelpers.number_format(input)
-  end
-
-  defp sanitize_params(params) do
-    params
-    |> Enum.map(&clear_param/1)
-    |> Enum.reject(&(&1 == ""))
-    |> Map.new()
-  end
-
-  defp clear_param({key, value}) when is_binary(value) do
-    {key, String.trim(value)}
-  end
-
-  defp clear_param(other) do
-    other
-  end
-
-  defp get_int_param(params, key) do
-    param = Map.get(params, key)
-    param = if param in ["", nil], do: "0", else: param
-
-    case Integer.parse(param) do
-      {integer, ""} -> integer
-      _ -> 0
-    end
-  end
-
-  defp update_features_to_list(params) do
-    features =
-      params["features[]"]
-      |> Enum.reject(fn {_key, value} -> value == "false" or value == "" end)
-      |> Enum.map(fn {key, _value} -> key end)
-
-    Map.put(params, "features", features)
-  end
-
-  defp preview_number(n) do
-    case Integer.parse("#{n}") do
-      {n, ""} ->
-        number_format(n) <>
-          " (#{PlausibleWeb.StatsView.large_number_format(n)})"
-
-      _ ->
-        "0"
-    end
-  end
-
-  attr :for, :any, required: true
-
-  defp preview(assigns) do
-    ~H"""
-    <.input
-      name={"#{@for.name}-preview"}
-      label="Preview"
-      autocomplete="off"
-      width="w-[500]"
-      readonly
-      value={preview_number(@for.value)}
-      class="bg-transparent border-0 p-0 m-0 text-sm w-full"
-    />
-    """
-  end
-
-  defp current_plan?(%{subscription: %{paddle_plan_id: id}}, id), do: true
-  defp current_plan?(_, _), do: false
-end