http://my-app.test {

    reverse_proxy localhost:4000

}

http://*.my-app.test {

    reverse_proxy localhost:4000

}

http://my-hostname.test {

    reverse_proxy localhost:4000

}

## Local DNS Hosting Setup

Testing custom domains and subdomains locally requires a reverse proxy to route `.test` domains to your Phoenix server. We use [Caddy](https://caddyserver.com/) for this.

### 1. Install Caddy

On macOS with Homebrew:

```sh

brew install caddy

```

For other platforms, see the [Caddy install docs](https://caddyserver.com/docs/install).

### 2. Configure local DNS

Add entries to `/etc/hosts` so `.test` domains resolve to localhost:

```

127.0.0.1 my-app.test

127.0.0.1 my-subdomain.my-app.test

127.0.0.1 my-hostname.test

```

Replace `my-subdomain` with the subdomain of a site you create in the app, and `my-hostname.test` with any custom domain you want to test hostname routing with.

### 3. Start Caddy

From the project root:

```sh

caddy run

```

This uses the `Caddyfile` in the project root, which proxies:

- `http://my-app.test` — the main app

- `http://*.my-app.test` — subdomain-based hosted sites

- `http://my-hostname.test` — custom domain hostname routing

### 4. Start Phoenix

```sh

mix phx.server

```

The dev endpoint is configured with `host: "my-app.test"` so the `ServeHostedSite` plug can distinguish between the main app, subdomains, and custom domains.

### 5. Test the flow

1. Visit `http://my-app.test` and log in

2. Create a site (e.g., name: "My Site", subdomain: "my-subdomain")

3. Visit `http://my-subdomain.my-app.test` to test subdomain routing

4. Add a hostname (e.g., `my-hostname.test`) to test custom domain routing

5. Visit `http://my-hostname.test` after adding the `/etc/hosts` entry

Note: DNS verification and certificate issuance are handled by the `LocalAdapter` in development, which auto-succeeds. Real DNS verification only applies in production.

  # http: [ip: {127, 0, 0, 1}],

  url: [host: "my-app.test", port: 80, scheme: "http"],

# DNS: use local resolver (auto-verifies all domains)

config :my_app, MyApp.Hosting.DNS, resolver: MyApp.Hosting.DNS.LocalResolver

# Certificates: use local adapter (logs operations, returns success)

config :my_app, MyApp.Hosting.Certificates, adapter: MyApp.Hosting.Certificates.LocalAdapter

    check_origin: :conn,

  fly_app_id =

    System.get_env("FLY_APP_NAME") ||

      raise "environment variable FLY_APP_NAME is missing"

  fly_api_token =

    System.get_env("FLY_API_TOKEN") ||

      raise "environment variable FLY_API_TOKEN is missing"

  config :my_app, MyApp.Hosting.Certificates,

    adapter: MyApp.Hosting.Certificates.FlyAdapter,

    app_id: fly_app_id,

    api_token: fly_api_token

  config :my_app, MyApp.Hosting.DNS,

    resolver: MyApp.Hosting.DNS.LiveResolver,

    cname_target: System.get_env("CNAME_TARGET", "#{fly_app_id}.fly.dev")

  url: [host: "www.example.com"],

defmodule MyApp.Hosting do

  @moduledoc """

  The Hosting context.

  """

  import Ecto.Query, warn: false

  alias MyApp.Repo

  alias MyApp.Hosting.Site

  alias MyApp.Accounts.Scope

  @doc """

  Subscribes to scoped notifications about any site changes.

  The broadcasted messages match the pattern:

    * {:created, %Site{}}

    * {:updated, %Site{}}

    * {:deleted, %Site{}}

  """

  def subscribe_sites(%Scope{} = scope) do

    key = scope.user.id

    Phoenix.PubSub.subscribe(MyApp.PubSub, "user:#{key}:sites")

  end

  defp broadcast_site(%Scope{} = scope, message) do

    key = scope.user.id

    Phoenix.PubSub.broadcast(MyApp.PubSub, "user:#{key}:sites", message)

  end

  @doc """

  Returns the list of sites.

  ## Examples

      iex> list_sites(scope)

      [%Site{}, ...]

  """

  def list_sites(%Scope{} = scope) do

    Repo.all_by(Site, user_id: scope.user.id)

  end

  @doc """

  Gets a single site.

  Raises `Ecto.NoResultsError` if the Site does not exist.

  ## Examples

      iex> get_site!(scope, 123)

      %Site{}

      iex> get_site!(scope, 456)

      ** (Ecto.NoResultsError)

  """

  def get_site!(%Scope{} = scope, id) do

    Repo.get_by!(Site, id: id, user_id: scope.user.id)

  end

  def get_site_by_subdomain(subdomain) do

    Repo.get_by(Site, subdomain: subdomain)

  end

  def get_site_by_hostname(domain) do

    Repo.one(

      from s in Site,

        join: h in assoc(s, :hostnames),

        where: h.domain == ^domain,

        where: not is_nil(h.verified_at),

        where: not is_nil(h.certificate_issued_at)

    )

  end

  @doc """

  Creates a site.

  ## Examples

      iex> create_site(scope, %{field: value})

      {:ok, %Site{}}

      iex> create_site(scope, %{field: bad_value})

      {:error, %Ecto.Changeset{}}

  """

  def create_site(%Scope{} = scope, attrs) do

    with {:ok, site = %Site{}} <-

           %Site{}

           |> Site.changeset(attrs, scope)

           |> Repo.insert() do

      broadcast_site(scope, {:created, site})

      {:ok, site}

    end

  end

  @doc """

  Updates a site.

  ## Examples

      iex> update_site(scope, site, %{field: new_value})

      {:ok, %Site{}}

      iex> update_site(scope, site, %{field: bad_value})

      {:error, %Ecto.Changeset{}}

  """

  def update_site(%Scope{} = scope, %Site{} = site, attrs) do

    true = site.user_id == scope.user.id

    with {:ok, site = %Site{}} <-

           site

           |> Site.changeset(attrs, scope)

           |> Repo.update() do

      broadcast_site(scope, {:updated, site})

      {:ok, site}

    end

  end

  @doc """

  Deletes a site.

  ## Examples

      iex> delete_site(scope, site)

      {:ok, %Site{}}

      iex> delete_site(scope, site)

      {:error, %Ecto.Changeset{}}

  """

  def delete_site(%Scope{} = scope, %Site{} = site) do

    true = site.user_id == scope.user.id

    with {:ok, site = %Site{}} <- Repo.delete(site) do

      broadcast_site(scope, {:deleted, site})

      {:ok, site}

    end

  end

  @doc """

  Returns an `%Ecto.Changeset{}` for tracking site changes.

  ## Examples

      iex> change_site(scope, site)

      %Ecto.Changeset{data: %Site{}}

  """

  def change_site(%Scope{} = scope, %Site{} = site, attrs \\ %{}) do

    true = site.user_id == scope.user.id

    Site.changeset(%{site | subdomain: nil}, attrs, scope, cast_default_subdomain: true)

  end

  alias MyApp.Hosting.Hostname

  alias MyApp.Hosting.DNS

  alias MyApp.Hosting.Certificates

  alias MyApp.Accounts.Scope

  @doc """

  Subscribes to scoped notifications about any hostname changes.

  The broadcasted messages match the pattern:

    * {:created, %Hostname{}}

    * {:updated, %Hostname{}}

    * {:deleted, %Hostname{}}

  """

  def subscribe_hostnames(%Scope{} = scope) do

    key = scope.user.id

    Phoenix.PubSub.subscribe(MyApp.PubSub, "user:#{key}:hostnames")

  end

  defp broadcast_hostname(%Scope{} = scope, message) do

    key = scope.user.id

    Phoenix.PubSub.broadcast(MyApp.PubSub, "user:#{key}:hostnames", message)

  end

  @doc """

  Returns the list of hostnames.

  ## Examples

      iex> list_hostnames(scope)

      [%Hostname{}, ...]

  """

  def list_hostnames(%Scope{} = _scope, site) do

    Repo.all_by(Hostname, site_id: site.id)

  end

  @doc """

  Gets a single hostname.

  Raises `Ecto.NoResultsError` if the Hostname does not exist.

  ## Examples

      iex> get_hostname!(scope, 123)

      %Hostname{}

      iex> get_hostname!(scope, 456)

      ** (Ecto.NoResultsError)

  """

  def get_hostname!(%Scope{} = _scope, site, id) do

    Repo.get_by!(Hostname, id: id, site_id: site.id)

  end

  @doc """

  Creates a hostname.

  ## Examples

      iex> create_hostname(scope, %{field: value})

      {:ok, %Hostname{}}

      iex> create_hostname(scope, %{field: bad_value})

      {:error, %Ecto.Changeset{}}

  """

  def create_hostname(%Scope{} = scope, site, attrs) do

    with {:ok, hostname = %Hostname{}} <-

           %Hostname{}

           |> Hostname.changeset(site, attrs)

           |> Repo.insert() do

      broadcast_hostname(scope, {:created, hostname})

      {:ok, hostname}

    end

  end

  @doc """

  Updates a hostname.

  ## Examples

      iex> update_hostname(scope, hostname, %{field: new_value})

      {:ok, %Hostname{}}

      iex> update_hostname(scope, hostname, %{field: bad_value})

      {:error, %Ecto.Changeset{}}

  """

  def update_hostname(%Scope{} = scope, %Hostname{} = hostname, site, attrs) do

    with {:ok, hostname = %Hostname{}} <-

           hostname

           |> Hostname.changeset(site, attrs)

           |> Repo.update() do

      broadcast_hostname(scope, {:updated, hostname})

      {:ok, hostname}

    end

  end

  @doc """

  Deletes a hostname.

  If the hostname has a certificate, it will be deleted from the certificate

  provider first. Certificate deletion failures are logged but don't prevent

  hostname deletion.

  ## Examples

      iex> delete_hostname(scope, hostname)

      {:ok, %Hostname{}}

      iex> delete_hostname(scope, hostname)

      {:error, %Ecto.Changeset{}}

  """

  def delete_hostname(%Scope{} = scope, %Hostname{} = hostname) do

    # Clean up certificate if one exists

    if hostname.certificate_requested_at do

      case Certificates.delete_certificate(hostname) do

        :ok ->

          :ok

        {:error, reason} ->

          require Logger

          Logger.warning(

            "Failed to delete certificate for #{hostname.domain}: #{inspect(reason)}"

          )

      end

    end

    with {:ok, hostname = %Hostname{}} <-

           Repo.delete(hostname) do

      broadcast_hostname(scope, {:deleted, hostname})

      {:ok, hostname}

    end

  end

  @doc """

  Returns an `%Ecto.Changeset{}` for tracking hostname changes.

  ## Examples

      iex> change_hostname(scope, hostname)

      %Ecto.Changeset{data: %Hostname{}}

  """

  def change_hostname(%Scope{} = _scope, %Hostname{} = hostname, site, attrs \\ %{}) do

    Hostname.changeset(hostname, site, attrs)

  end

  @doc """

  Verifies a hostname by checking for the expected TXT record.

  If verification succeeds, updates the hostname with the current timestamp

  in `verified_at`.

  Returns:

    - `{:ok, %Hostname{}}` if verification succeeds

    - `{:error, :not_found}` if the TXT record is not found

    - `{:error, :dns_error}` if the DNS lookup fails

  ## Examples

      iex> verify_hostname(scope, hostname)

      {:ok, %Hostname{verified_at: ~U[2024-01-01 12:00:00Z]}}

  """

  def verify_hostname(%Scope{} = scope, %Hostname{} = hostname) do

    case DNS.verify_domain(hostname) do

      {:ok, :verified} ->

        {:ok, updated} =

          hostname

          |> Hostname.verification_changeset(DateTime.utc_now(:second))

          |> Repo.update()

        broadcast_hostname(scope, {:updated, updated})

        {:ok, updated}

      {:error, reason} ->

        {:error, reason}

    end

  end

  @doc """

  Returns the DNS verification instructions for a hostname.

  ## Examples

      iex> verification_instructions(hostname)

      %{

        hostname: "_myapp-verify.example.com",

        record_type: "TXT",

        record_value: "myapp-verification=abc123..."

      }

  """

  def verification_instructions(%Hostname{} = hostname) do

    %{

      host: DNS.verification_host(),

      record_type: "TXT",

      record_value: DNS.verification_record_value(hostname.txt_record_secret)

    }

  end

  @doc """

  Returns the CNAME record instructions for pointing a domain to the app.

  ## Examples

      iex> cname_instructions(hostname)

      %{

        hostname: "example.com",

        record_type: "CNAME",

        record_value: "proxy.fly.dev"

      }

  """

  def cname_instructions(%Hostname{} = _hostname) do

    %{

      host: "@",

      record_type: "CNAME",

      record_value: DNS.cname_target()

    }

  end

  @doc """

  Issues a TLS certificate for a verified hostname.

  The domain must be verified (have a non-nil `verified_at`) before a

  certificate can be issued. Sets `certificate_requested_at` immediately,

  and only sets `certificate_issued_at` when the adapter reports the

  certificate as issued.

  Returns:

    - `{:ok, %Hostname{}}` with updated certificate fields on success

    - `{:error, :domain_not_verified}` if the domain isn't verified

    - `{:error, reason}` if certificate issuance fails

  """

  def issue_certificate(%Scope{}, %Hostname{verified_at: nil}) do

    {:error, :domain_not_verified}

  end

  def issue_certificate(%Scope{} = scope, %Hostname{} = hostname) do

    case Certificates.issue_certificate(hostname) do

      {:ok, cert_result} ->

        now = DateTime.utc_now(:second)

        attrs = %{

          certificate_requested_at: now,

          certificate_issued_at:

            if(cert_result.status == :issued, do: cert_result.issued_at || now)

        }

        {:ok, updated} =

          hostname

          |> Hostname.certificate_changeset(attrs)

          |> Repo.update()

        broadcast_hostname(scope, {:updated, updated})

        {:ok, updated}

      {:error, reason} ->

        {:error, reason}

    end

  end

  @doc """

  Checks the certificate status with the provider and updates the hostname

  record if the certificate has been issued.

  Returns:

    - `{:ok, %Hostname{}}` with updated fields if status changed

    - `{:ok, :pending}` if the certificate is still pending

    - `{:error, reason}` if the check fails

  """

  def refresh_certificate_status(%Scope{} = scope, %Hostname{} = hostname) do

    case Certificates.check_certificate(hostname) do

      {:ok, %{status: :issued} = cert_result} ->

        attrs = %{

          certificate_issued_at: cert_result.issued_at || DateTime.utc_now(:second)

        }

        {:ok, updated} =

          hostname

          |> Hostname.certificate_changeset(attrs)

          |> Repo.update()

        broadcast_hostname(scope, {:updated, updated})

        {:ok, updated}

      {:ok, %{status: status}} ->

        {:ok, status}

      {:error, reason} ->

        {:error, reason}

    end

  end

  @doc """

  Deletes the certificate for a hostname.

  Also clears the certificate fields on the hostname record.

  """

  def delete_certificate(%Scope{} = scope, %Hostname{} = hostname) do

    case Certificates.delete_certificate(hostname) do

      :ok ->

        {:ok, updated} =

          hostname

          |> Hostname.certificate_changeset(%{

            certificate_requested_at: nil,

            certificate_issued_at: nil

          })

          |> Repo.update()

        broadcast_hostname(scope, {:updated, updated})

        {:ok, updated}

      {:error, reason} ->

        {:error, reason}

    end

  end

end

defmodule MyApp.Hosting.Certificates do

  @moduledoc """

  Certificate management for custom domains.

  This module provides a unified interface for issuing and managing

  TLS certificates for custom domains. The underlying implementation

  is configurable:

  - Production: Fly.io GraphQL API

  - Development: Caddy API (for local testing)

  - Test: Mock adapter

  ## Configuration

      # config/prod.exs

      config :my_app, MyApp.Hosting.Certificates,

        adapter: MyApp.Hosting.Certificates.FlyAdapter,

        app_id: "your-fly-app-id",

        api_token: System.get_env("FLY_API_TOKEN")

      # config/dev.exs

      config :my_app, MyApp.Hosting.Certificates,

        adapter: MyApp.Hosting.Certificates.CaddyAdapter,

        caddy_admin_url: "http://localhost:2019"

      # config/test.exs

      config :my_app, MyApp.Hosting.Certificates,

        adapter: MyApp.Hosting.Certificates.MockAdapter

  """

  alias MyApp.Hosting.Hostname

  @type certificate_status :: :pending | :issued | :error

  @type certificate_result :: %{

          hostname: String.t(),

          status: certificate_status(),

          dns_validation_hostname: String.t() | nil,

          dns_validation_target: String.t() | nil,

          issued_at: DateTime.t() | nil,

          expires_at: DateTime.t() | nil,

          error: String.t() | nil

        }

  @doc """

  Callback for adding a certificate for a hostname.

  """

  @callback add_certificate(hostname :: String.t(), opts :: keyword()) ::

              {:ok, certificate_result()} | {:error, term()}

  @doc """

  Callback for checking certificate status.

  """

  @callback check_certificate(hostname :: String.t(), opts :: keyword()) ::

              {:ok, certificate_result()} | {:error, term()}

  @doc """

  Callback for removing a certificate.

  """

  @callback delete_certificate(hostname :: String.t(), opts :: keyword()) ::

              :ok | {:error, term()}

  @doc """

  Issues a certificate for a hostname.

  """

  def issue_certificate(%Hostname{} = hostname) do

    adapter().add_certificate(hostname.domain, adapter_opts())

  end

  @doc """

  Checks the certificate status for a hostname.

  """

  def check_certificate(%Hostname{} = hostname) do

    adapter().check_certificate(hostname.domain, adapter_opts())

  end

  @doc """

  Removes the certificate for a hostname.

  """

  def delete_certificate(%Hostname{} = hostname) do

    adapter().delete_certificate(hostname.domain, adapter_opts())

  end

  defp adapter do

    config()[:adapter] || raise "No certificate adapter configured"

  end

  defp adapter_opts do

    config()

    |> Keyword.drop([:adapter])

  end

  defp config do

    Application.get_env(:my_app, __MODULE__, [])

  end

end

defmodule MyApp.Hosting.Certificates.FlyAdapter do

  @moduledoc """

  Certificate adapter for Fly.io's GraphQL API.

  ## Configuration

      config :my_app, MyApp.Hosting.Certificates,

        adapter: MyApp.Hosting.Certificates.FlyAdapter,

        app_id: "your-fly-app-id",

        api_token: System.get_env("FLY_API_TOKEN")

  """

  @behaviour MyApp.Hosting.Certificates

  @api_url "https://api.fly.io/graphql"

  @impl true

  def add_certificate(hostname, opts) do

    app_id = Keyword.fetch!(opts, :app_id)

    query = """

    mutation($appId: ID!, $hostname: String!) {

      addCertificate(appId: $appId, hostname: $hostname) {

        certificate {

          configured

          acmeDnsConfigured

          acmeAlpnConfigured

          certificateAuthority

          certificateRequestedAt

          dnsProvider

          dnsValidationInstructions

          dnsValidationHostname

          dnsValidationTarget

          hostname

          id

          source

        }

      }

    }

    """

    variables = %{appId: app_id, hostname: hostname}

    case graphql_request(query, variables, opts) do

      {:ok, %{"addCertificate" => %{"certificate" => cert}}} ->

        {:ok, parse_certificate(cert)}

      {:ok, %{"errors" => errors}} ->

        {:error, parse_errors(errors)}

      {:error, reason} ->

        {:error, reason}

    end

  end

  @impl true

  def check_certificate(hostname, opts) do

    app_name = Keyword.get(opts, :app_name) || Keyword.fetch!(opts, :app_id)

    query = """

    query($appName: String!, $hostname: String!) {

      app(name: $appName) {

        certificate(hostname: $hostname) {

          check

          configured

          acmeDnsConfigured

          acmeAlpnConfigured

          certificateAuthority

          createdAt

          dnsProvider

          dnsValidationInstructions

          dnsValidationHostname

          dnsValidationTarget

          hostname

          id

          source

          clientStatus

          issued {

            nodes {

              type

              expiresAt

            }

          }

        }

      }

    }

    """

    variables = %{appName: app_name, hostname: hostname}

    case graphql_request(query, variables, opts) do

      {:ok, %{"app" => %{"certificate" => cert}}} when not is_nil(cert) ->

        {:ok, parse_certificate(cert)}

      {:ok, %{"app" => %{"certificate" => nil}}} ->

        {:error, :not_found}

      {:ok, %{"errors" => errors}} ->

        {:error, parse_errors(errors)}

      {:error, reason} ->

        {:error, reason}

    end

  end

  @impl true

  def delete_certificate(hostname, opts) do

    app_id = Keyword.fetch!(opts, :app_id)

    query = """

    mutation($appId: ID!, $hostname: String!) {

      deleteCertificate(appId: $appId, hostname: $hostname) {

        app {

          name

        }

        certificate {

          hostname

          id

        }

      }

    }

    """

    variables = %{appId: app_id, hostname: hostname}

    case graphql_request(query, variables, opts) do

      {:ok, %{"deleteCertificate" => _}} ->

        :ok

      {:ok, %{"errors" => errors}} ->

        {:error, parse_errors(errors)}

      {:error, reason} ->

        {:error, reason}

    end

  end

  defp graphql_request(query, variables, opts) do

    api_token = Keyword.fetch!(opts, :api_token)

    headers = [

      {"authorization", "Bearer #{api_token}"},

      {"content-type", "application/json"}

    ]

    body = Jason.encode!(%{query: query, variables: variables})

    case Req.post(@api_url, body: body, headers: headers, decode_body: false) do

      {:ok, %Req.Response{status: 200, body: response_body}} ->

        {:ok, Jason.decode!(response_body)["data"]}

      {:ok, %Req.Response{status: status, body: response_body}} ->

        {:error, {:http_error, status, response_body}}

      {:error, reason} ->

        {:error, reason}

    end

  end

  defp parse_certificate(cert) do

    issued = get_in(cert, ["issued", "nodes"]) || []

    expires_at =

      case Enum.find(issued, &(&1["type"] == "ecdsa")) || List.first(issued) do

        %{"expiresAt" => exp} when is_binary(exp) ->

          case DateTime.from_iso8601(exp) do

            {:ok, dt, _} -> dt

            _ -> nil

          end

        _ ->

          nil

      end

    status =

      cond do

        Enum.any?(issued) -> :issued

        cert["configured"] -> :pending

        true -> :pending

      end

    %{

      hostname: cert["hostname"],

      status: status,

      dns_validation_hostname: cert["dnsValidationHostname"],

      dns_validation_target: cert["dnsValidationTarget"],

      issued_at: parse_datetime(cert["createdAt"]),

      expires_at: expires_at,

      error: nil

    }

  end

  defp parse_datetime(nil), do: nil

  defp parse_datetime(str) when is_binary(str) do

    case DateTime.from_iso8601(str) do

      {:ok, dt, _} -> dt

      _ -> nil

    end

  end

  defp parse_errors(errors) when is_list(errors) do

    errors

    |> Enum.map(& &1["message"])

    |> Enum.join(", ")

  end

  defp parse_errors(error), do: inspect(error)

end

defmodule MyApp.Hosting.Certificates.LocalAdapter do

  @moduledoc """

  Certificate adapter for local development.

  This adapter logs certificate operations and returns success responses.

  Use this when running with Caddy or another local reverse proxy that

  handles TLS termination.

  For local development with Caddy, configure on-demand TLS in your Caddyfile:

      {

        on_demand_tls {

          ask http://localhost:4000/api/domains/check

        }

      }

      https:// {

        tls {

          on_demand

        }

        reverse_proxy localhost:4000

      }

  ## Configuration

      config :my_app, MyApp.Hosting.Certificates,

        adapter: MyApp.Hosting.Certificates.LocalAdapter

  """

  @behaviour MyApp.Hosting.Certificates

  require Logger

  @impl true

  def add_certificate(hostname, _opts) do

    Logger.info("[Certificates.LocalAdapter] Adding certificate for #{hostname}")

    {:ok,

     %{

       hostname: hostname,

       status: :issued,

       dns_validation_hostname: nil,

       dns_validation_target: nil,

       issued_at: DateTime.utc_now(),

       expires_at: DateTime.utc_now() |> DateTime.add(90, :day),

       error: nil

     }}

  end

  @impl true

  def check_certificate(hostname, _opts) do

    Logger.debug("[Certificates.LocalAdapter] Checking certificate for #{hostname}")

    {:ok,

     %{

       hostname: hostname,

       status: :issued,

       dns_validation_hostname: nil,

       dns_validation_target: nil,

       issued_at: DateTime.utc_now() |> DateTime.add(-1, :day),

       expires_at: DateTime.utc_now() |> DateTime.add(89, :day),

       error: nil

     }}

  end

  @impl true

  def delete_certificate(hostname, _opts) do

    Logger.info("[Certificates.LocalAdapter] Deleting certificate for #{hostname}")

    :ok

  end

end

defmodule MyApp.Hosting.Certificates.MockAdapter do

  @moduledoc """

  Mock certificate adapter for testing.

  Uses the process dictionary to store mock responses, allowing tests to

  control the behavior per-hostname.

  ## Usage in Tests

      setup do

        Application.put_env(:my_app, MyApp.Hosting.Certificates,

          adapter: MyApp.Hosting.Certificates.MockAdapter

        )

        on_exit(fn ->

          Application.delete_env(:my_app, MyApp.Hosting.Certificates)

        end)

      end

      test "issues certificate" do

        MockAdapter.mock_add_certificate("example.com", {:ok, %{status: :pending}})

        assert {:ok, %{status: :pending}} = Certificates.issue_certificate(domain_alias)

      end

  """

  @behaviour MyApp.Hosting.Certificates

  @doc """

  Mock the response for `add_certificate/2`.

  """

  def mock_add_certificate(hostname, response) do

    Process.put({__MODULE__, :add, hostname}, response)

  end

  @doc """

  Mock the response for `check_certificate/2`.

  """

  def mock_check_certificate(hostname, response) do

    Process.put({__MODULE__, :check, hostname}, response)

  end

  @doc """

  Mock the response for `delete_certificate/2`.

  """

  def mock_delete_certificate(hostname, response) do

    Process.put({__MODULE__, :delete, hostname}, response)

  end

  @impl true

  def add_certificate(hostname, _opts) do

    case Process.get({__MODULE__, :add, hostname}) do

      nil -> default_add_response(hostname)

      response -> response

    end

  end

  @impl true

  def check_certificate(hostname, _opts) do

    case Process.get({__MODULE__, :check, hostname}) do

      nil -> default_check_response(hostname)

      response -> response

    end

  end

  @impl true

  def delete_certificate(hostname, _opts) do

    case Process.get({__MODULE__, :delete, hostname}) do

      nil -> :ok

      response -> response

    end

  end

  defp default_add_response(hostname) do

    {:ok,

     %{

       hostname: hostname,

       status: :pending,

       dns_validation_hostname: "_acme-challenge.#{hostname}",

       dns_validation_target: "#{hostname}.fly.dev",

       issued_at: nil,

       expires_at: nil,

       error: nil

     }}

  end

  defp default_check_response(hostname) do

    {:ok,

     %{

       hostname: hostname,

       status: :issued,

       dns_validation_hostname: nil,

       dns_validation_target: nil,

       issued_at: DateTime.utc_now() |> DateTime.add(-1, :hour),

       expires_at: DateTime.utc_now() |> DateTime.add(90, :day),

       error: nil

     }}

  end

end

defmodule MyApp.Hosting.DNS do

  @moduledoc """

  DNS verification for custom domains.

  Users verify domain ownership by adding a TXT record containing

  their unique verification token. The underlying DNS lookup is

  delegated to a configurable resolver:

  - Production: `MyApp.Hosting.DNS.LiveResolver` (real DNS lookups)

  - Development: `MyApp.Hosting.DNS.LocalResolver` (auto-verifies)

  - Test: Mock resolver via process dictionary

  ## Configuration

      # config/runtime.exs (production)

      config :my_app, MyApp.Hosting.DNS,

        resolver: MyApp.Hosting.DNS.LiveResolver

      # config/dev.exs

      config :my_app, MyApp.Hosting.DNS,

        resolver: MyApp.Hosting.DNS.LocalResolver

  """

  alias MyApp.Hosting.Hostname

  @verification_prefix "myapp-verification="

  @verification_subdomain "_myapp-verify"

  @default_cname_target "proxy.fly.dev"

  @doc """

  Callback for looking up TXT records for a hostname.

  """

  @callback lookup_txt(hostname :: String.t()) :: {:ok, [String.t()]} | {:error, atom()}

  @doc """

  Verifies a domain alias by checking for the expected TXT record.

  Looks for a TXT record at `_myapp-verify.<domain>` containing:

      myapp-verification=<txt_record_secret>

  Returns:

    - `{:ok, :verified}` if the correct TXT record is found

    - `{:error, :not_found}` if no matching TXT record exists

    - `{:error, :dns_error}` if the DNS lookup fails

  ## Examples

      iex> verify_domain(%Hostname{domain: "example.com", txt_record_secret: "abc123"})

      {:ok, :verified}

      iex> verify_domain(%Hostname{domain: "unverified.com", txt_record_secret: "abc123"})

      {:error, :not_found}

  """

  @spec verify_domain(Hostname.t()) :: {:ok, :verified} | {:error, :not_found | :dns_error}

  def verify_domain(%Hostname{} = hostname) do

    verify_domain(hostname.domain, hostname.txt_record_secret)

  end

  @doc """

  Verifies a domain by checking for the expected TXT record.

  See `verify_domain/1` for details.

  """

  @spec verify_domain(String.t(), String.t()) ::

          {:ok, :verified} | {:error, :not_found | :dns_error}

  def verify_domain(domain, expected_secret)

      when is_binary(domain) and is_binary(expected_secret) do

    verification_host = verification_hostname(domain)

    expected_value = @verification_prefix <> expected_secret

    case lookup_txt_records(verification_host) do

      {:ok, records} ->

        if Enum.any?(records, &(&1 == expected_value)) do

          {:ok, :verified}

        else

          {:error, :not_found}

        end

      {:error, _reason} ->

        {:error, :dns_error}

    end

  end

  @doc """

  Returns the DNS host label for the TXT verification record (without the domain).

  ## Examples

      iex> verification_host()

      "_myapp-verify"

  """

  @spec verification_host() :: String.t()

  def verification_host, do: @verification_subdomain

  @doc """

  Returns the full hostname where the TXT verification record should be set.

  ## Examples

      iex> verification_hostname("example.com")

      "_myapp-verify.example.com"

  """

  @spec verification_hostname(String.t()) :: String.t()

  def verification_hostname(domain) do

    "#{@verification_subdomain}.#{domain}"

  end

  @doc """

  Returns the full TXT record value that should be set for verification.

  ## Examples

      iex> verification_record_value("abc123secret")

      "myapp-verification=abc123secret"

  """

  @spec verification_record_value(String.t()) :: String.t()

  def verification_record_value(secret) do

    @verification_prefix <> secret

  end

  @doc """

  Returns the CNAME target where custom domains should point.

  Configurable via:

      config :my_app, MyApp.Hosting.DNS, cname_target: "your-app.fly.dev"

  ## Examples

      iex> cname_target()

      "proxy.fly.dev"

  """

  @spec cname_target() :: String.t()

  def cname_target do

    config()[:cname_target] || @default_cname_target

  end

  @doc """

  Looks up TXT records for a given hostname.

  Delegates to the configured resolver.

  ## Examples

      iex> lookup_txt_records("example.com")

      {:ok, ["v=spf1 include:_spf.google.com ~all", "myapp-verification=abc123"]}

  """

  @spec lookup_txt_records(String.t()) :: {:ok, [String.t()]} | {:error, atom()}

  def lookup_txt_records(hostname) when is_binary(hostname) do

    resolver().lookup_txt(hostname)

  end

  defp resolver do

    config()[:resolver] || raise "No DNS resolver configured"

  end

  defp config do

    Application.get_env(:my_app, __MODULE__, [])

  end

end

defmodule MyApp.Hosting.DNS.LiveResolver do

  @moduledoc """

  DNS resolver that performs real TXT record lookups via `:inet_res`.

  ## Configuration

      config :my_app, MyApp.Hosting.DNS,

        resolver: MyApp.Hosting.DNS.LiveResolver

  """

  @behaviour MyApp.Hosting.DNS

  @dns_timeout 5_000

  @impl true

  def lookup_txt(hostname) when is_binary(hostname) do

    hostname_charlist = String.to_charlist(hostname)

    case :inet_res.lookup(hostname_charlist, :in, :txt, timeout: @dns_timeout) do

      [] ->

        # Empty result could mean no records or NXDOMAIN - check explicitly

        case :inet_res.resolve(hostname_charlist, :in, :txt, timeout: @dns_timeout) do

          {:ok, _} -> {:ok, []}

          {:error, reason} -> {:error, reason}

        end

      records when is_list(records) ->

        # TXT records come back as lists of charlists, flatten and convert

        parsed =

          records

          |> Enum.map(&parse_txt_record/1)

          |> Enum.reject(&is_nil/1)

        {:ok, parsed}

    end

  rescue

    _ -> {:error, :dns_error}

  end

  # TXT records can be split into multiple strings (each max 255 chars)

  # :inet_res returns them as a list of charlists that need to be joined

  defp parse_txt_record(record) when is_list(record) do

    record

    |> Enum.map(&to_string/1)

    |> Enum.join()

  rescue

    _ -> nil

  end

end

defmodule MyApp.Hosting.DNS.LocalResolver do

  @moduledoc """

  DNS resolver for local development that auto-verifies all domains.

  Returns the queried hostname as a TXT record value, which means

  `verify_domain/1` will always find a matching record as long as the

  hostname has a valid `txt_record_secret`.

  ## Configuration

      config :my_app, MyApp.Hosting.DNS, resolver: MyApp.Hosting.DNS.LocalResolver

  """

  @behaviour MyApp.Hosting.DNS

  require Logger

  @verification_prefix "myapp-verification="

  @impl true

  def lookup_txt(hostname) do

    Logger.info("[DNS.LocalResolver] Auto-verifying TXT lookup for #{hostname}")

    # Extract the secret from the database by pattern-matching the verification hostname,

    # but since we don't have DB access here, return all possible prefixed values.

    # Instead, we use a simpler approach: look up the hostname record and return

    # whatever the caller expects.

    #

    # Since we can't know the expected secret here, we query the DB for it.

    case lookup_hostname_secret(hostname) do

      {:ok, secret} -> {:ok, [@verification_prefix <> secret]}

      :error -> {:ok, []}

    end

  end

  defp lookup_hostname_secret(verification_hostname) do

    # Strip the "_myapp-verify." prefix to get the actual domain

    case String.split(verification_hostname, ".", parts: 2) do

      ["_myapp-verify", domain] ->

        case MyApp.Repo.get_by(MyApp.Hosting.Hostname, domain: domain) do

          %{txt_record_secret: secret} -> {:ok, secret}

          nil -> :error

        end

      _ ->

        :error

    end

  end

end

defmodule MyApp.Hosting.Hostname do

  use Ecto.Schema

  import Ecto.Changeset

  @rand_size 32

  @primary_key {:id, :binary_id, autogenerate: true}

  @foreign_key_type :binary_id

  schema "hostnames" do

    field :domain, :string

    field :txt_record_secret, :string

    field :verified_at, :utc_datetime

    field :certificate_requested_at, :utc_datetime

    field :certificate_issued_at, :utc_datetime

    belongs_to :site, MyApp.Hosting.Site

    timestamps(type: :utc_datetime)

  end

  @domain_regex ~r/^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}$/i

  def changeset(hostname, site, attrs) do

    hostname

    |> cast(attrs, [:domain])

    |> validate_required([:domain])

    |> update_change(:domain, &String.downcase/1)

    |> validate_format(:domain, @domain_regex,

      message: "must be a valid domain (e.g., example.com)"

    )

    |> validate_length(:domain, max: 253)

    |> unique_constraint(:domain, message: "is already registered")

    |> maybe_generate_secret()

    |> put_change(:site_id, site.id)

  end

  defp maybe_generate_secret(%{data: %{txt_record_secret: nil}} = changeset) do

    put_change(changeset, :txt_record_secret, generate_secret_token())

  end

  defp maybe_generate_secret(changeset), do: changeset

  def generate_secret_token do

    token = :crypto.strong_rand_bytes(@rand_size)

    Base.encode64(token, padding: false)

  end

  def verification_changeset(hostname, verified_at) do

    hostname

    |> change(verified_at: verified_at)

  end

  def certificate_changeset(hostname, attrs) do

    hostname

    |> cast(attrs, [:certificate_requested_at, :certificate_issued_at])

  end

end

defmodule MyApp.Hosting.Site do

  use Ecto.Schema

  import Ecto.Changeset

  @primary_key {:id, :binary_id, autogenerate: true}

  @foreign_key_type :binary_id

  schema "sites" do

    field :name, :string

    field :subdomain, :string

    belongs_to :user, MyApp.Accounts.User

    has_many :hostnames, MyApp.Hosting.Hostname

    timestamps(type: :utc_datetime)

  end

  @subdomain_regex ~r/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/

  def changeset(site, attrs, user_scope, opts \\ []) do

    site

    |> cast(attrs, [:name, :subdomain])

    |> cast_default_subdomain(opts)

    |> validate_required([:name, :subdomain])

    |> validate_format(:subdomain, @subdomain_regex,

      message: "must be lowercase alphanumeric characters and hyphens only"

    )

    |> validate_length(:subdomain, max: 63)

    |> unique_constraint(:subdomain)

    |> put_change(:user_id, user_scope.user.id)

  end

  def cast_default_subdomain(changeset, opts) do

    case {opts[:cast_default_subdomain], fetch_field(changeset, :name)} do

      {true, {_type, name}} when is_binary(name) ->

        put_change(changeset, :subdomain, name_to_subdomain(name))

      _otherwise ->

        changeset

    end

  end

  def name_to_subdomain(name) when is_binary(name) do

    name

    |> String.downcase()

    |> String.replace(~r/[^a-z0-9]/, "-")

    |> String.trim("-")

  end

  def name_to_subdomain(_), do: ""

end

defmodule MyAppWeb.HostedController do

  use MyAppWeb, :controller