Error Pages

lib/beacon/content.ex

@@ -26,6 +26,7 @@ defmodule Beacon.Content do
   import Ecto.Query
 
   alias Beacon.Content.Component
+  alias Beacon.Content.ErrorPage
   alias Beacon.Content.Layout
   alias Beacon.Content.LayoutEvent
   alias Beacon.Content.LayoutSnapshot
@@ -73,6 +74,18 @@ defmodule Beacon.Content do
     Layout.changeset(layout, attrs)
   end
 
+  @doc """
+  Returns a map of attrs to load the default layout into new sites.
+  """
+  @spec default_layout() :: map()
+  @doc type: :layouts
+  def default_layout do
+    %{
+      title: "Default",
+      template: "<%= @inner_content %>"
+    }
+  end
+
   @doc """
   Creates a layout.
 
@@ -1667,6 +1680,108 @@ defmodule Beacon.Content do
     end
   end
 
+  # ERROR PAGES
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking error page changes.
+
+  ## Example
+
+      iex> change_error_page(error_page, %{status: 404})
+      %Ecto.Changeset{data: %ErrorPage{}}
+
+  """
+  @doc type: :error_pages
+  @spec change_error_page(ErrorPage.t(), map()) :: Changeset.t()
+  def change_error_page(%ErrorPage{} = error_page, attrs \\ %{}) do
+    ErrorPage.changeset(error_page, attrs)
+  end
+
+  @doc """
+  Returns the error page for a given site and status code, or `nil` if no matching error page exists.
+  """
+  @doc type: :error_pages
+  @spec get_error_page(Site.t(), integer()) :: ErrorPage.t() | nil
+  def get_error_page(site, status) do
+    Repo.one(
+      from e in ErrorPage,
+        where: e.site == ^site,
+        where: e.status == ^status
+    )
+  end
+
+  @doc """
+  Lists all error pages for a given site.
+  """
+  @doc type: :error_pages
+  @spec list_error_pages(Site.t()) :: [ErrorPage.t()]
+  def list_error_pages(site) do
+    Repo.all(
+      from e in ErrorPage,
+        where: e.site == ^site,
+        order_by: e.status
+    )
+  end
+
+  @doc """
+  Creates a new error page.
+  """
+  @doc type: :error_pages
+  @spec create_error_page(%{site: Site.t(), status: integer(), template: binary(), layout_id: Ecto.UUID.t()}) ::
+          {:ok, ErrorPage.t()} | {:error, Changeset.t()}
+  def create_error_page(attrs) do
+    %ErrorPage{}
+    |> ErrorPage.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Creates a new error page, raising if the operation fails.
+  """
+  @doc type: :error_pages
+  @spec create_error_page!(%{site: Site.t(), status: integer(), template: binary(), layout_id: Ecto.UUID.t()}) ::
+          ErrorPage.t()
+  def create_error_page!(attrs) do
+    case create_error_page(attrs) do
+      {:ok, error_page} -> error_page
+      {:error, changeset} -> raise "failed to create error page, got: #{inspect(changeset.errors)}"
+    end
+  end
+
+  @doc """
+  Returns attr data to load the default error_pages into new sites.
+  """
+  @spec default_error_pages() :: [map()]
+  @doc type: :error_pages
+  def default_error_pages do
+    for status <- [404, 500] do
+      %{
+        status: status,
+        template: Plug.Conn.Status.reason_phrase(status)
+      }
+    end
+  end
+
+  @doc """
+  Updates an error page.
+  """
+  @doc type: :error_pages
+  @spec update_error_page(ErrorPage.t(), map()) :: {:ok, ErrorPage.t()} | {:error, Changeset.t()}
+  def update_error_page(error_page, attrs) do
+    error_page
+    |> ErrorPage.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes an error page.
+  """
+  @doc type: :error_pages
+  @spec delete_error_page(ErrorPage.t()) :: {:ok, ErrorPage.t()} | {:error, Changeset.t()}
+  def delete_error_page(error_page) do
+    Repo.delete(error_page)
+  end
+
   # PAGE EVENT HANDLERS
 
   @doc """

lib/beacon/content/error_page.ex

@@ -0,0 +1,55 @@
+defmodule Beacon.Content.ErrorPage do
+  @moduledoc """
+  Stores a template which can be rendered for error responses.
+
+  An ErrorPage contains four main fields:
+
+    * `:status` - the status code for which this ErrorPage is to be used
+    * `:template` - the template to be rendered
+    * `:site` - the Beacon site which should use this page
+    * `:layout_id` - the ID of the Beacon Layout which is used for rendering
+
+  > #### Do not create or edit ErrorPages manually {: .warning}
+  >
+  > Use the public functions in `Beacon.Content` instead.
+  > The functions in that module guarantee that all dependencies
+  > are created correctly and all processes are updated.
+  > Manipulating data manually will most likely result
+  > in inconsistent behavior and crashes.
+
+  """
+  use Beacon.Schema
+
+  import Ecto.Changeset
+
+  @type t :: %__MODULE__{
+          id: Ecto.UUID.t(),
+          site: Beacon.Types.Site.t(),
+          status: integer,
+          template: binary(),
+          layout_id: Ecto.UUID.t(),
+          layout: Beacon.Content.Layout.t(),
+          inserted_at: DateTime.t(),
+          updated_at: DateTime.t()
+        }
+
+  schema "beacon_error_pages" do
+    field :site, Beacon.Types.Site
+    field :status, :integer
+    field :template, :string
+
+    belongs_to :layout, Beacon.Content.Layout
+
+    timestamps()
+  end
+
+  @doc false
+  def changeset(%__MODULE__{} = error_page, attrs) do
+    fields = ~w(status template site layout_id)a
+
+    error_page
+    |> cast(attrs, fields)
+    |> validate_required(fields)
+    |> unique_constraint([:status, :site])
+  end
+end

lib/beacon/loader.ex

@@ -36,17 +36,21 @@ defmodule Beacon.Loader do
 
   @doc false
   def init(config) do
+    %{site: site} = config
+
     if Code.ensure_loaded?(Mix.Project) and Mix.env() == :test do
       :skip
     else
-      with :ok <- populate_components(config.site) do
-        :ok = load_site_from_db(config.site)
+      with :ok <- populate_components(site),
+           :ok <- populate_layouts(site),
+           :ok <- populate_error_pages(site) do
+        :ok = load_site_from_db(site)
       end
     end
 
-    PubSub.subscribe_to_layouts(config.site)
-    PubSub.subscribe_to_pages(config.site)
-    PubSub.subscribe_to_components(config.site)
+    PubSub.subscribe_to_layouts(site)
+    PubSub.subscribe_to_pages(site)
+    PubSub.subscribe_to_components(site)
 
     {:ok, config}
   end
@@ -67,6 +71,39 @@ defmodule Beacon.Loader do
     :ok
   end
 
+  defp populate_layouts(site) do
+    case Content.get_layout_by(site, title: "Default") do
+      nil ->
+        Content.default_layout()
+        |> Map.put(:site, site)
+        |> Content.create_layout!()
+
+      _ ->
+        :skip
+    end
+
+    :ok
+  end
+
+  defp populate_error_pages(site) do
+    default_layout = Content.get_layout_by(site, title: "Default")
+
+    for attrs <- Content.default_error_pages() do
+      case Content.get_error_page(site, attrs.status) do
+        nil ->
+          attrs
+          |> Map.put(:site, site)
+          |> Map.put(:layout_id, default_layout.id)
+          |> Content.create_error_page!()
+
+        _ ->
+          :skip
+      end
+    end
+
+    :ok
+  end
+
   defp load_site_from_db(site) do
     with :ok <- Beacon.RuntimeJS.load(),
          :ok <- load_runtime_css(site),

lib/beacon_web/controllers/error_html.ex

@@ -1,21 +1,21 @@
 defmodule BeaconWeb.ErrorHTML do
   @moduledoc false
-
   use BeaconWeb, :html
 
-  # If you want to customize your error pages,
-  # uncomment the embed_templates/1 call below
-  # and add pages to the error directory:
-  #
-  #   * lib/beacon_web/controllers/error/404.html.heex
-  #   * lib/beacon_web/controllers/error/500.html.heex
-  #
-  # embed_templates "error/*"
+  def render(template, assigns) do
+    {_, _, %{extra: %{session: %{"beacon_site" => site}}}} = assigns.conn.private.phoenix_live_view
+
+    status =
+      template
+      |> String.split(".")
+      |> hd()
+      |> String.to_integer()
+
+    %{layout: %{template: layout_template}, template: page_template} =
+      site
+      |> Beacon.Content.get_error_page(status)
+      |> Beacon.Repo.preload(:layout)
 
-  # The default is to render a plain text page based on
-  # the template name. For example, "404.html" becomes
-  # "Not Found".
-  def render(template, _assigns) do
-    Phoenix.Controller.status_message_from_template(template)
+    EEx.eval_string(layout_template, assigns: [inner_content: page_template])
   end
 end

lib/mix/tasks/install.ex

@@ -34,6 +34,7 @@ defmodule Mix.Tasks.Beacon.Install do
 
     config_file_path = config_file_path("config.exs")
     maybe_inject_beacon_repo_into_ecto_repos(config_file_path)
+    inject_endpoint_render_errors_config(config_file_path)
 
     dev_config_file = config_file_path("dev.exs")
     maybe_inject_beacon_repo_config(dev_config_file, bindings)
@@ -91,6 +92,37 @@ defmodule Mix.Tasks.Beacon.Install do
     end
   end
 
+  @doc false
+  def inject_endpoint_render_errors_config(config_file_path) do
+    config_file_content = File.read!(config_file_path)
+
+    if String.contains?(config_file_content, "BeaconWeb.ErrorHTML") do
+      Mix.shell().info([
+        :yellow,
+        "* skip ",
+        :reset,
+        "injecting Beacon.ErrorHTML to render_errors into ",
+        Path.relative_to_cwd(config_file_path),
+        " (already exists)"
+      ])
+    else
+      regex = ~r/(config.*\.Endpoint,\n)((?:.+\n)*\s*)\n/
+      render_errors_value = [formats: [html: BeaconWeb.ErrorHTML]]
+
+      [_header, endpoint_config_str] = Regex.run(regex, config_file_content, capture: :all_but_first)
+      {config_list, []} = Code.eval_string("[" <> endpoint_config_str <> "]")
+      updated_config_list = Keyword.update(config_list, :render_errors, render_errors_value, fn _ -> render_errors_value end)
+      updated_str = inspect(updated_config_list) <> "\n"
+
+      new_config_file_content =
+        regex
+        |> Regex.replace(config_file_content, "\\1#{updated_str}")
+        |> Code.format_string!(file: config_file_path)
+
+      File.write!(config_file_path, [new_config_file_content, "\n"])
+    end
+  end
+
   @doc false
   def maybe_inject_beacon_repo_config(config_file_path, bindings) do
     config_file_content = File.read!(config_file_path)

mix.exs

@@ -94,6 +94,7 @@ defmodule Beacon.MixProject do
         Content: [
           Beacon.Content,
           Beacon.Content.Component,
+          Beacon.Content.ErrorPage,
           Beacon.Content.Layout,
           Beacon.Content.LayoutEvent,
           Beacon.Content.LayoutSnapshot,
@@ -171,7 +172,8 @@ defmodule Beacon.MixProject do
         "Functions: Stylesheets": &(&1[:type] == :stylesheets),
         "Functions: Components": &(&1[:type] == :components),
         "Functions: Snippets": &(&1[:type] == :snippets),
-        "Functions: Page Event Handlers": &(&1[:type] == :page_event_handlers)
+        "Functions: Page Event Handlers": &(&1[:type] == :page_event_handlers),
+        "Functions: Error Pages": &(&1[:type] == :error_pages)
       ]
     ]
   end

priv/repo/migrations/20230816195326_create_error_pages.exs

@@ -0,0 +1,17 @@
+defmodule Beacon.Repo.Migrations.CreateErrorPages do
+  use Ecto.Migration
+
+  def change do
+    create table(:beacon_error_pages, primary_key: false) do
+      add :id, :binary_id, primary_key: true
+      add :site, :text, null: false
+      add :status, :integer, null: false
+      add :template, :text, null: false
+      add :layout_id, references(:beacon_layouts, type: :binary_id)
+
+      timestamps()
+    end
+
+    create unique_index(:beacon_error_pages, [:status, :site])
+  end
+end