Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.
TypeScript analyticsanalytics-dashboardclickhouseelixirgoogle-analyticsmarketingopen-source-analyticsphoenixplausible-analyticspostgresqlprivacyprivacy-friendlyself-hostedsimple-analyticsstatisticstailwindcssweb-analyticswebsite-analyticswebsite-statswebsite-tracking
Implement `SSO.Domains.lookup` and `SSO.Domains.add` (#5419)
Adrian Gruntkowski0b7bccd6a5c1
diff --git a/extra/lib/plausible/auth/sso/domain.ex b/extra/lib/plausible/auth/sso/domain.exindex 7097b49f94..a3dcda00ce 100644--- a/extra/lib/plausible/auth/sso/domain.ex+++ b/extra/lib/plausible/auth/sso/domain.ex@@ -15,12 +15,18 @@ defmodule Plausible.Auth.SSO.Domain doimport Ecto.Changeset+ alias Plausible.Auth.SSO++ @validation_methods [:dns_txt, :url, :meta_tag]+@type t() :: %__MODULE__{}+ @type validation_method() :: unquote(Enum.reduce(@validation_methods, &{:|, [], [&1, &2]}))+schema "sso_domains" dofield :identifier, Ecto.UUIDfield :domain, :string- field :validated_via, Ecto.Enum, values: [:dns_txt, :url, :meta_tag]+ field :validated_via, Ecto.Enum, values: @validation_methodsfield :last_validated_at, :naive_datetimefield :status, Ecto.Enum, values: [:pending, :validated], default: :pending@@ -29,9 +35,84 @@ defmodule Plausible.Auth.SSO.Domain dotimestamps()end- def create_changeset(name) do+ @spec create_changeset(SSO.Integration.t(), String.t() | nil) :: Ecto.Changeset.t()+ def create_changeset(integration, domain) do%__MODULE__{}- |> cast(%{name: name}, [:name])- |> validate_required(:name)+ |> cast(%{domain: domain}, [:domain])+ |> validate_required(:domain)+ |> normalize_domain(:domain)+ |> validate_domain(:domain)+ |> unique_constraint(:domain, message: "is already in use")+ |> put_change(:identifier, Ecto.UUID.generate())+ |> put_assoc(:sso_integration, integration)+ end++ @spec valid_changeset(t(), validation_method(), NaiveDateTime.t()) ::+ Ecto.Changeset.t()+ def valid_changeset(sso_domain, method, now) do+ sso_domain+ |> change()+ |> put_change(:validated_via, method)+ |> put_change(:last_validated_at, now)+ |> put_change(:status, :validated)+ end++ @spec invalid_changeset(t(), NaiveDateTime.t()) :: Ecto.Changeset.t()+ def invalid_changeset(sso_domain, now) do+ sso_domain+ |> change()+ |> put_change(:validated_via, nil)+ |> put_change(:last_validated_at, now)+ |> put_change(:status, :pending)+ end++ @spec valid_domain?(String.t()) :: boolean()+ def valid_domain?(domain) do+ # This is not a surefire way to ensure the domain is correct,+ # but it should give a bit more confidence that it's at least+ # resolvable.+ case URI.new("https://" <> domain) do+ {:ok, %{host: host, port: port, path: nil, query: nil, fragment: nil, userinfo: nil}}+ when is_binary(host) and port in [80, 443] ->+ true++ _ ->+ false+ end+ end++ defp normalize_domain(changeset, field) do+ if domain = get_change(changeset, field) do+ # We try to clear the usual copy-paste prefixes.+ normalized =+ domain+ |> String.trim()+ |> String.downcase()+ |> String.split("://", parts: 2)+ |> List.last()+ |> String.trim("/")++ case URI.new("https://" <> normalized) do+ {:ok, %{host: host}} when is_binary(host) and host != "" ->+ put_change(changeset, field, host)++ _ ->+ put_change(changeset, field, normalized)+ end+ else+ changeset+ end+ end++ defp validate_domain(changeset, field) do+ if domain = get_change(changeset, field) do+ if valid_domain?(domain) do+ changeset+ else+ add_error(changeset, field, "invalid domain", validation: :domain)+ end+ else+ changeset+ endendenddiff --git a/extra/lib/plausible/auth/sso/domains.ex b/extra/lib/plausible/auth/sso/domains.exnew file mode 100644index 0000000000..4212ae8925--- /dev/null+++ b/extra/lib/plausible/auth/sso/domains.ex@@ -0,0 +1,72 @@+defmodule Plausible.Auth.SSO.Domains do+ @moduledoc """+ API for SSO domains.+ """++ import Ecto.Query++ alias Plausible.Auth.SSO+ alias Plausible.Repo++ @spec add(SSO.Integration.t(), String.t()) ::+ {:ok, SSO.Domain.t()} | {:error, Ecto.Changeset.t()}+ def add(integration, domain) do+ changeset = SSO.Domain.create_changeset(integration, domain)++ Repo.insert(changeset)+ end++ @spec verify(SSO.Domain.t(), Keyword.t()) :: SSO.Domain.t()+ def verify(sso_domain, opts \\ []) do+ skip_checks? = Keyword.get(opts, :skip_checks?, false)+ now = Keyword.get(opts, :now, NaiveDateTime.utc_now(:second))++ if skip_checks? do+ mark_valid(sso_domain, :dns_txt, now)+ else+ mark_invalid(sso_domain, now)+ end+ end++ @spec lookup(String.t()) :: {:ok, SSO.Domain.t()} | {:error, :not_found}+ def lookup(domain_or_email) when is_binary(domain_or_email) do+ search = normalize_lookup(domain_or_email)++ result =+ from(+ d in SSO.Domain,+ inner_join: i in assoc(d, :sso_integration),+ inner_join: t in assoc(i, :team),+ where: d.domain == ^search,+ where: d.status == :validated,+ preload: [sso_integration: {i, team: t}]+ )+ |> Repo.one()++ if result do+ {:ok, result}+ else+ {:error, :not_found}+ end+ end++ defp normalize_lookup(domain_or_email) do+ domain_or_email+ |> String.split("@", parts: 2)+ |> List.last()+ |> String.trim()+ |> String.downcase()+ end++ defp mark_valid(sso_domain, method, now) do+ sso_domain+ |> SSO.Domain.valid_changeset(method, now)+ |> Repo.update!()+ end++ defp mark_invalid(sso_domain, now) do+ sso_domain+ |> SSO.Domain.invalid_changeset(now)+ |> Repo.update!()+ end+enddiff --git a/test/plausible/auth/sso/domains_test.exs b/test/plausible/auth/sso/domains_test.exsnew file mode 100644index 0000000000..a766f282ba--- /dev/null+++ b/test/plausible/auth/sso/domains_test.exs@@ -0,0 +1,182 @@+defmodule Plausible.Auth.SSO.DomainsTest do+ use Plausible.DataCase, async: true+ use Plausible++ on_ee do+ use Plausible.Teams.Test++ alias Plausible.Auth.SSO+ alias Plausible.Teams++ setup do+ team = new_site().team++ integration = SSO.initiate_saml_integration(team)++ {:ok, team: team, integration: integration}+ end++ describe "add/2" do+ test "adds a new domain", %{integration: integration} do+ domain = generate_domain()++ assert {:ok, sso_domain} = SSO.Domains.add(integration, domain)++ assert sso_domain.domain == domain+ assert is_binary(sso_domain.identifier)+ refute sso_domain.validated_via+ refute sso_domain.last_validated_at+ assert sso_domain.status == :pending+ end++ test "normalizes domain before adding", %{integration: integration} do+ domain = generate_domain()++ inputs = [+ " " <> String.upcase(domain) <> " ",+ "https://" <> domain,+ "http://" <> domain,+ "http://" <> domain <> "/",+ "//" <> domain,+ "//" <> domain <> ":1234",+ "https://" <> domain <> ":443",+ "ftp://" <> domain,+ domain <> "/path",+ "https://" <> domain <> "?query=string",+ "https://" <> domain <> "#fragment",+ "https://user:info@" <> domain+ ]++ for input <- inputs do+ assert {:ok, sso_domain} = SSO.Domains.add(integration, input)+ assert sso_domain.domain == domain+ Repo.delete!(sso_domain)+ end+ end++ test "rejects empty domain", %{integration: integration} do+ assert {:error, changeset} = SSO.Domains.add(integration, " ")++ assert %{domain: [:required]} =+ Ecto.Changeset.traverse_errors(changeset, fn {_msg, opts} ->+ opts[:validation]+ end)+ end++ test "rejects invalid domain", %{integration: integration} do+ assert {:error, _changeset} = SSO.Domains.add(integration, "invalid domain")+ assert {:error, _changeset} = SSO.Domains.add(integration, "invalid domain.com")+ end++ test "rejects already added domain", %{integration: integration} do+ domain = generate_domain()+ {:ok, _} = SSO.Domains.add(integration, domain)++ assert {:error, changeset} = SSO.Domains.add(integration, domain)++ assert %{domain: [:unique]} =+ Ecto.Changeset.traverse_errors(changeset, fn {_msg, opts} ->+ opts[:constraint]+ end)+ end++ test "rejects domain which is already added in another team", %{integration: integration} do+ domain = generate_domain()+ {:ok, _} = SSO.Domains.add(integration, domain)++ other_team = new_site().team+ other_integration = SSO.initiate_saml_integration(other_team)++ assert {:error, changeset} = SSO.Domains.add(other_integration, domain)++ assert %{domain: [:unique]} =+ Ecto.Changeset.traverse_errors(changeset, fn {_msg, opts} ->+ opts[:constraint]+ end)+ end+ end++ describe "verify/2" do+ test "marks domain as validated when skip_checks? option passed", %{+ integration: integration+ } do+ domain = generate_domain()+ {:ok, sso_domain} = SSO.Domains.add(integration, domain)++ valid_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)++ assert valid_domain.id == sso_domain.id+ assert valid_domain.validated_via == :dns_txt+ assert valid_domain.status == :validated+ assert valid_domain.last_validated_at+ end++ test "does not mark domain as validated when no skip flag passed", %{+ integration: integration+ } do+ domain = generate_domain()+ {:ok, sso_domain} = SSO.Domains.add(integration, domain)++ invalid_domain = SSO.Domains.verify(sso_domain)++ assert invalid_domain.id == sso_domain.id+ refute invalid_domain.validated_via+ assert invalid_domain.status == :pending+ assert invalid_domain.last_validated_at+ end+ end++ describe "lookup/1" do+ test "looks up domain by email", %{integration: integration} do+ domain = generate_domain()+ {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)++ email = "mary.jane@" <> domain++ assert {:ok, found_sso_domain} = SSO.Domains.lookup(email)++ assert found_sso_domain.id == sso_domain.id+ assert %SSO.Integration{} = found_sso_domain.sso_integration+ assert %Teams.Team{} = found_sso_domain.sso_integration.team+ end++ test "looks up domain by plain domain", %{integration: integration} do+ domain = generate_domain()+ {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)++ assert {:ok, found_sso_domain} = SSO.Domains.lookup(domain)+ assert found_sso_domain.id == sso_domain.id+ end++ test "normalizes input removing whitespace and capitalizations", %{integration: integration} do+ domain = generate_domain()+ {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)++ email = " maRy.jAnE@" <> String.upcase(domain) <> " "++ assert {:ok, found_sso_domain} = SSO.Domains.lookup(email)+ assert found_sso_domain.id == sso_domain.id+ end++ test "returns error if matching domain is not validated", %{integration: integration} do+ domain = generate_domain()+ {:ok, _sso_domain} = SSO.Domains.add(integration, domain)++ assert {:error, :not_found} = SSO.Domains.lookup(domain)+ end++ test "returns error if domain not found" do+ domain = generate_domain()++ assert {:error, :not_found} = SSO.Domains.lookup(domain)+ end+ end++ defp generate_domain() do+ "example-#{Enum.random(1..10_000)}.com"+ end+ end+end