Add all

lib/nulla/accounts.ex

@@ -0,0 +1,377 @@
+defmodule Nulla.Accounts do
+  @moduledoc """
+  The Accounts context.
+  """
+
+  import Ecto.Query, warn: false
+  alias Nulla.Repo
+
+  alias Nulla.Accounts.{User, UserToken, UserNotifier}
+
+  ## Database getters
+
+  @doc """
+  Gets a user by email.
+
+  ## Examples
+
+      iex> get_user_by_email("foo@example.com")
+      %User{}
+
+      iex> get_user_by_email("unknown@example.com")
+      nil
+
+  """
+  def get_user_by_email(email) when is_binary(email) do
+    Repo.get_by(User, email: email)
+  end
+
+  @doc """
+  Gets a user by email and password.
+
+  ## Examples
+
+      iex> get_user_by_email_and_password("foo@example.com", "correct_password")
+      %User{}
+
+      iex> get_user_by_email_and_password("foo@example.com", "invalid_password")
+      nil
+
+  """
+  def get_user_by_email_and_password(email, password)
+      when is_binary(email) and is_binary(password) do
+    user = Repo.get_by(User, email: email)
+    if User.valid_password?(user, password), do: user
+  end
+
+  @doc """
+  Gets a single user.
+
+  Raises `Ecto.NoResultsError` if the User does not exist.
+
+  ## Examples
+
+      iex> get_user!(123)
+      %User{}
+
+      iex> get_user!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_user!(id), do: Repo.get!(User, id)
+
+  ## User registration
+
+  @doc """
+  Registers a user.
+
+  ## Examples
+
+      iex> register_user(%{field: value})
+      {:ok, %User{}}
+
+      iex> register_user(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def register_user(attrs) do
+    %User{}
+    |> User.registration_changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking user changes.
+
+  ## Examples
+
+      iex> change_user_registration(user)
+      %Ecto.Changeset{data: %User{}}
+
+  """
+  def change_user_registration(%User{} = user, attrs \\ %{}) do
+    User.registration_changeset(user, attrs, hash_password: false, validate_email: false)
+  end
+
+  ## Settings
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for changing the user email.
+
+  ## Examples
+
+      iex> change_user_email(user)
+      %Ecto.Changeset{data: %User{}}
+
+  """
+  def change_user_email(user, attrs \\ %{}) do
+    User.email_changeset(user, attrs, validate_email: false)
+  end
+
+  @doc """
+  Emulates that the email will change without actually changing
+  it in the database.
+
+  ## Examples
+
+      iex> apply_user_email(user, "valid password", %{email: ...})
+      {:ok, %User{}}
+
+      iex> apply_user_email(user, "invalid password", %{email: ...})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def apply_user_email(user, password, attrs) do
+    user
+    |> User.email_changeset(attrs)
+    |> User.validate_current_password(password)
+    |> Ecto.Changeset.apply_action(:update)
+  end
+
+  @doc """
+  Updates the user email using the given token.
+
+  If the token matches, the user email is updated and the token is deleted.
+  The confirmed_at date is also updated to the current time.
+  """
+  def update_user_email(user, token) do
+    context = "change:#{user.email}"
+
+    with {:ok, query} <- UserToken.verify_change_email_token_query(token, context),
+         %UserToken{sent_to: email} <- Repo.one(query),
+         {:ok, _} <- Repo.transaction(user_email_multi(user, email, context)) do
+      :ok
+    else
+      _ -> :error
+    end
+  end
+
+  defp user_email_multi(user, email, context) do
+    changeset =
+      user
+      |> User.email_changeset(%{email: email})
+      |> User.confirm_changeset()
+
+    Ecto.Multi.new()
+    |> Ecto.Multi.update(:user, changeset)
+    |> Ecto.Multi.delete_all(:tokens, UserToken.by_user_and_contexts_query(user, [context]))
+  end
+
+  @doc ~S"""
+  Delivers the update email instructions to the given user.
+
+  ## Examples
+
+      iex> deliver_user_update_email_instructions(user, current_email, &url(~p"/users/settings/confirm_email/#{&1}"))
+      {:ok, %{to: ..., body: ...}}
+
+  """
+  def deliver_user_update_email_instructions(%User{} = user, current_email, update_email_url_fun)
+      when is_function(update_email_url_fun, 1) do
+    {encoded_token, user_token} = UserToken.build_email_token(user, "change:#{current_email}")
+
+    Repo.insert!(user_token)
+    UserNotifier.deliver_update_email_instructions(user, update_email_url_fun.(encoded_token))
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for changing the user password.
+
+  ## Examples
+
+      iex> change_user_password(user)
+      %Ecto.Changeset{data: %User{}}
+
+  """
+  def change_user_password(user, attrs \\ %{}) do
+    User.password_changeset(user, attrs, hash_password: false)
+  end
+
+  @doc """
+  Updates the user password.
+
+  ## Examples
+
+      iex> update_user_password(user, "valid password", %{password: ...})
+      {:ok, %User{}}
+
+      iex> update_user_password(user, "invalid password", %{password: ...})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_user_password(user, password, attrs) do
+    changeset =
+      user
+      |> User.password_changeset(attrs)
+      |> User.validate_current_password(password)
+
+    Ecto.Multi.new()
+    |> Ecto.Multi.update(:user, changeset)
+    |> Ecto.Multi.delete_all(:tokens, UserToken.by_user_and_contexts_query(user, :all))
+    |> Repo.transaction()
+    |> case do
+      {:ok, %{user: user}} -> {:ok, user}
+      {:error, :user, changeset, _} -> {:error, changeset}
+    end
+  end
+
+  ## Session
+
+  @doc """
+  Generates a session token.
+  """
+  def generate_user_session_token(user) do
+    {token, user_token} = UserToken.build_session_token(user)
+    Repo.insert!(user_token)
+    token
+  end
+
+  @doc """
+  Gets the user with the given signed token.
+  """
+  def get_user_by_session_token(token) do
+    {:ok, query} = UserToken.verify_session_token_query(token)
+    Repo.one(query)
+  end
+
+  @doc """
+  Deletes the signed token with the given context.
+  """
+  def delete_user_session_token(token) do
+    Repo.delete_all(UserToken.by_token_and_context_query(token, "session"))
+    :ok
+  end
+
+  ## Confirmation
+
+  @doc ~S"""
+  Delivers the confirmation email instructions to the given user.
+
+  ## Examples
+
+      iex> deliver_user_confirmation_instructions(user, &url(~p"/users/confirm/#{&1}"))
+      {:ok, %{to: ..., body: ...}}
+
+      iex> deliver_user_confirmation_instructions(confirmed_user, &url(~p"/users/confirm/#{&1}"))
+      {:error, :already_confirmed}
+
+  """
+  def deliver_user_confirmation_instructions(%User{} = user, confirmation_url_fun)
+      when is_function(confirmation_url_fun, 1) do
+    if user.confirmed_at do
+      {:error, :already_confirmed}
+    else
+      {encoded_token, user_token} = UserToken.build_email_token(user, "confirm")
+      Repo.insert!(user_token)
+      UserNotifier.deliver_confirmation_instructions(user, confirmation_url_fun.(encoded_token))
+    end
+  end
+
+  @doc """
+  Confirms a user by the given token.
+
+  If the token matches, the user account is marked as confirmed
+  and the token is deleted.
+  """
+  def confirm_user(token) do
+    with {:ok, query} <- UserToken.verify_email_token_query(token, "confirm"),
+         %User{} = user <- Repo.one(query),
+         {:ok, %{user: user}} <- Repo.transaction(confirm_user_multi(user)) do
+      {:ok, user}
+    else
+      _ -> :error
+    end
+  end
+
+  defp confirm_user_multi(user) do
+    Ecto.Multi.new()
+    |> Ecto.Multi.update(:user, User.confirm_changeset(user))
+    |> Ecto.Multi.delete_all(:tokens, UserToken.by_user_and_contexts_query(user, ["confirm"]))
+  end
+
+  ## Reset password
+
+  @doc ~S"""
+  Delivers the reset password email to the given user.
+
+  ## Examples
+
+      iex> deliver_user_reset_password_instructions(user, &url(~p"/users/reset_password/#{&1}"))
+      {:ok, %{to: ..., body: ...}}
+
+  """
+  def deliver_user_reset_password_instructions(%User{} = user, reset_password_url_fun)
+      when is_function(reset_password_url_fun, 1) do
+    {encoded_token, user_token} = UserToken.build_email_token(user, "reset_password")
+    Repo.insert!(user_token)
+    UserNotifier.deliver_reset_password_instructions(user, reset_password_url_fun.(encoded_token))
+  end
+
+  @doc """
+  Gets the user by reset password token.
+
+  ## Examples
+
+      iex> get_user_by_reset_password_token("validtoken")
+      %User{}
+
+      iex> get_user_by_reset_password_token("invalidtoken")
+      nil
+
+  """
+  def get_user_by_reset_password_token(token) do
+    with {:ok, query} <- UserToken.verify_email_token_query(token, "reset_password"),
+         %User{} = user <- Repo.one(query) do
+      user
+    else
+      _ -> nil
+    end
+  end
+
+  @doc """
+  Resets the user password.
+
+  ## Examples
+
+      iex> reset_user_password(user, %{password: "new long password", password_confirmation: "new long password"})
+      {:ok, %User{}}
+
+      iex> reset_user_password(user, %{password: "valid", password_confirmation: "not the same"})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def reset_user_password(user, attrs) do
+    Ecto.Multi.new()
+    |> Ecto.Multi.update(:user, User.password_changeset(user, attrs))
+    |> Ecto.Multi.delete_all(:tokens, UserToken.by_user_and_contexts_query(user, :all))
+    |> Repo.transaction()
+    |> case do
+      {:ok, %{user: user}} -> {:ok, user}
+      {:error, :user, changeset, _} -> {:error, changeset}
+    end
+  end
+
+  @doc """
+  Creates a new api token for a user.
+
+  The token returned must be saved somewhere safe.
+  This token cannot be recovered from the database.
+  """
+  def create_user_api_token(user) do
+    {encoded_token, user_token} = UserToken.build_email_token(user, "api-token")
+    Repo.insert!(user_token)
+    encoded_token
+  end
+
+  @doc """
+  Fetches the user by API token.
+  """
+  def fetch_user_by_api_token(token) do
+    with {:ok, query} <- UserToken.verify_email_token_query(token, "api-token"),
+         %User{} = user <- Repo.one(query) do
+      {:ok, user}
+    else
+      _ -> :error
+    end
+  end
+end

lib/nulla/accounts/user.ex

@@ -0,0 +1,171 @@
+defmodule Nulla.Accounts.User do
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Ecto.Changeset
+  alias Nulla.Snowflake
+
+  @primary_key {:id, :integer, autogenerate: false}
+  schema "users" do
+    field :email, :string
+    field :password, :string, virtual: true, redact: true
+    field :hashed_password, :string, redact: true
+    field :current_password, :string, virtual: true, redact: true
+    field :confirmed_at, :utc_datetime
+
+    timestamps(type: :utc_datetime)
+  end
+
+  @doc """
+  A user changeset for registration.
+
+  It is important to validate the length of both email and password.
+  Otherwise databases may truncate the email without warnings, which
+  could lead to unpredictable or insecure behaviour. Long passwords may
+  also be very expensive to hash for certain algorithms.
+
+  ## Options
+
+    * `:hash_password` - Hashes the password so it can be stored securely
+      in the database and ensures the password field is cleared to prevent
+      leaks in the logs. If password hashing is not needed and clearing the
+      password field is not desired (like when using this changeset for
+      validations on a LiveView form), this option can be set to `false`.
+      Defaults to `true`.
+
+    * `:validate_email` - Validates the uniqueness of the email, in case
+      you don't want to validate the uniqueness of the email (like when
+      using this changeset for validations on a LiveView form before
+      submitting the form), this option can be set to `false`.
+      Defaults to `true`.
+  """
+  def registration_changeset(user, attrs, opts \\ []) do
+    user
+    |> cast(attrs, [:email, :password])
+    |> maybe_put_id()
+    |> validate_email(opts)
+    |> validate_password(opts)
+  end
+
+  defp maybe_put_id(%Changeset{data: %{id: nil}} = changeset) do
+    change(changeset, id: Snowflake.next_id())
+  end
+
+  defp maybe_put_id(changeset), do: changeset
+
+  defp validate_email(changeset, opts) do
+    changeset
+    |> validate_required([:email])
+    |> validate_format(:email, ~r/^[^\s]+@[^\s]+$/, message: "must have the @ sign and no spaces")
+    |> validate_length(:email, max: 160)
+    |> maybe_validate_unique_email(opts)
+  end
+
+  defp validate_password(changeset, opts) do
+    changeset
+    |> validate_required([:password])
+    |> validate_length(:password, min: 12, max: 72)
+    # Examples of additional password validation:
+    # |> validate_format(:password, ~r/[a-z]/, message: "at least one lower case character")
+    # |> validate_format(:password, ~r/[A-Z]/, message: "at least one upper case character")
+    # |> validate_format(:password, ~r/[!?@#$%^&*_0-9]/, message: "at least one digit or punctuation character")
+    |> maybe_hash_password(opts)
+  end
+
+  defp maybe_hash_password(changeset, opts) do
+    hash_password? = Keyword.get(opts, :hash_password, true)
+    password = get_change(changeset, :password)
+
+    if hash_password? && password && changeset.valid? do
+      changeset
+      # If using Bcrypt, then further validate it is at most 72 bytes long
+      |> validate_length(:password, max: 72, count: :bytes)
+      # Hashing could be done with `Ecto.Changeset.prepare_changes/2`, but that
+      # would keep the database transaction open longer and hurt performance.
+      |> put_change(:hashed_password, Bcrypt.hash_pwd_salt(password))
+      |> delete_change(:password)
+    else
+      changeset
+    end
+  end
+
+  defp maybe_validate_unique_email(changeset, opts) do
+    if Keyword.get(opts, :validate_email, true) do
+      changeset
+      |> unsafe_validate_unique(:email, Nulla.Repo)
+      |> unique_constraint(:email)
+    else
+      changeset
+    end
+  end
+
+  @doc """
+  A user changeset for changing the email.
+
+  It requires the email to change otherwise an error is added.
+  """
+  def email_changeset(user, attrs, opts \\ []) do
+    user
+    |> cast(attrs, [:email])
+    |> validate_email(opts)
+    |> case do
+      %{changes: %{email: _}} = changeset -> changeset
+      %{} = changeset -> add_error(changeset, :email, "did not change")
+    end
+  end
+
+  @doc """
+  A user changeset for changing the password.
+
+  ## Options
+
+    * `:hash_password` - Hashes the password so it can be stored securely
+      in the database and ensures the password field is cleared to prevent
+      leaks in the logs. If password hashing is not needed and clearing the
+      password field is not desired (like when using this changeset for
+      validations on a LiveView form), this option can be set to `false`.
+      Defaults to `true`.
+  """
+  def password_changeset(user, attrs, opts \\ []) do
+    user
+    |> cast(attrs, [:password])
+    |> validate_confirmation(:password, message: "does not match password")
+    |> validate_password(opts)
+  end
+
+  @doc """
+  Confirms the account by setting `confirmed_at`.
+  """
+  def confirm_changeset(user) do
+    now = DateTime.utc_now() |> DateTime.truncate(:second)
+    change(user, confirmed_at: now)
+  end
+
+  @doc """
+  Verifies the password.
+
+  If there is no user or the user doesn't have a password, we call
+  `Bcrypt.no_user_verify/0` to avoid timing attacks.
+  """
+  def valid_password?(%Nulla.Accounts.User{hashed_password: hashed_password}, password)
+      when is_binary(hashed_password) and byte_size(password) > 0 do
+    Bcrypt.verify_pass(password, hashed_password)
+  end
+
+  def valid_password?(_, _) do
+    Bcrypt.no_user_verify()
+    false
+  end
+
+  @doc """
+  Validates the current password otherwise adds an error to the changeset.
+  """
+  def validate_current_password(changeset, password) do
+    changeset = cast(changeset, %{current_password: password}, [:current_password])
+
+    if valid_password?(changeset.data, password) do
+      changeset
+    else
+      add_error(changeset, :current_password, "is not valid")
+    end
+  end
+end

lib/nulla/accounts/user_notifier.ex

@@ -0,0 +1,79 @@
+defmodule Nulla.Accounts.UserNotifier do
+  import Swoosh.Email
+
+  alias Nulla.Mailer
+
+  # Delivers the email using the application mailer.
+  defp deliver(recipient, subject, body) do
+    email =
+      new()
+      |> to(recipient)
+      |> from({"Nulla", "contact@example.com"})
+      |> subject(subject)
+      |> text_body(body)
+
+    with {:ok, _metadata} <- Mailer.deliver(email) do
+      {:ok, email}
+    end
+  end
+
+  @doc """
+  Deliver instructions to confirm account.
+  """
+  def deliver_confirmation_instructions(user, url) do
+    deliver(user.email, "Confirmation instructions", """
+
+    ==============================
+
+    Hi #{user.email},
+
+    You can confirm your account by visiting the URL below:
+
+    #{url}
+
+    If you didn't create an account with us, please ignore this.
+
+    ==============================
+    """)
+  end
+
+  @doc """
+  Deliver instructions to reset a user password.
+  """
+  def deliver_reset_password_instructions(user, url) do
+    deliver(user.email, "Reset password instructions", """
+
+    ==============================
+
+    Hi #{user.email},
+
+    You can reset your password by visiting the URL below:
+
+    #{url}
+
+    If you didn't request this change, please ignore this.
+
+    ==============================
+    """)
+  end
+
+  @doc """
+  Deliver instructions to update a user email.
+  """
+  def deliver_update_email_instructions(user, url) do
+    deliver(user.email, "Update email instructions", """
+
+    ==============================
+
+    Hi #{user.email},
+
+    You can change your email by visiting the URL below:
+
+    #{url}
+
+    If you didn't request this change, please ignore this.
+
+    ==============================
+    """)
+  end
+end

lib/nulla/accounts/user_token.ex

@@ -0,0 +1,179 @@
+defmodule Nulla.Accounts.UserToken do
+  use Ecto.Schema
+  import Ecto.Query
+  alias Nulla.Accounts.UserToken
+
+  @hash_algorithm :sha256
+  @rand_size 32
+
+  # It is very important to keep the reset password token expiry short,
+  # since someone with access to the email may take over the account.
+  @reset_password_validity_in_days 1
+  @confirm_validity_in_days 7
+  @change_email_validity_in_days 7
+  @session_validity_in_days 60
+
+  schema "users_tokens" do
+    field :token, :binary
+    field :context, :string
+    field :sent_to, :string
+    belongs_to :user, Nulla.Accounts.User
+
+    timestamps(type: :utc_datetime, updated_at: false)
+  end
+
+  @doc """
+  Generates a token that will be stored in a signed place,
+  such as session or cookie. As they are signed, those
+  tokens do not need to be hashed.
+
+  The reason why we store session tokens in the database, even
+  though Phoenix already provides a session cookie, is because
+  Phoenix' default session cookies are not persisted, they are
+  simply signed and potentially encrypted. This means they are
+  valid indefinitely, unless you change the signing/encryption
+  salt.
+
+  Therefore, storing them allows individual user
+  sessions to be expired. The token system can also be extended
+  to store additional data, such as the device used for logging in.
+  You could then use this information to display all valid sessions
+  and devices in the UI and allow users to explicitly expire any
+  session they deem invalid.
+  """
+  def build_session_token(user) do
+    token = :crypto.strong_rand_bytes(@rand_size)
+    {token, %UserToken{token: token, context: "session", user_id: user.id}}
+  end
+
+  @doc """
+  Checks if the token is valid and returns its underlying lookup query.
+
+  The query returns the user found by the token, if any.
+
+  The token is valid if it matches the value in the database and it has
+  not expired (after @session_validity_in_days).
+  """
+  def verify_session_token_query(token) do
+    query =
+      from token in by_token_and_context_query(token, "session"),
+        join: user in assoc(token, :user),
+        where: token.inserted_at > ago(@session_validity_in_days, "day"),
+        select: user
+
+    {:ok, query}
+  end
+
+  @doc """
+  Builds a token and its hash to be delivered to the user's email.
+
+  The non-hashed token is sent to the user email while the
+  hashed part is stored in the database. The original token cannot be reconstructed,
+  which means anyone with read-only access to the database cannot directly use
+  the token in the application to gain access. Furthermore, if the user changes
+  their email in the system, the tokens sent to the previous email are no longer
+  valid.
+
+  Users can easily adapt the existing code to provide other types of delivery methods,
+  for example, by phone numbers.
+  """
+  def build_email_token(user, context) do
+    build_hashed_token(user, context, user.email)
+  end
+
+  defp build_hashed_token(user, context, sent_to) do
+    token = :crypto.strong_rand_bytes(@rand_size)
+    hashed_token = :crypto.hash(@hash_algorithm, token)
+
+    {Base.url_encode64(token, padding: false),
+     %UserToken{
+       token: hashed_token,
+       context: context,
+       sent_to: sent_to,
+       user_id: user.id
+     }}
+  end
+
+  @doc """
+  Checks if the token is valid and returns its underlying lookup query.
+
+  The query returns the user found by the token, if any.
+
+  The given token is valid if it matches its hashed counterpart in the
+  database and the user email has not changed. This function also checks
+  if the token is being used within a certain period, depending on the
+  context. The default contexts supported by this function are either
+  "confirm", for account confirmation emails, and "reset_password",
+  for resetting the password. For verifying requests to change the email,
+  see `verify_change_email_token_query/2`.
+  """
+  def verify_email_token_query(token, context) do
+    case Base.url_decode64(token, padding: false) do
+      {:ok, decoded_token} ->
+        hashed_token = :crypto.hash(@hash_algorithm, decoded_token)
+        days = days_for_context(context)
+
+        query =
+          from token in by_token_and_context_query(hashed_token, context),
+            join: user in assoc(token, :user),
+            where: token.inserted_at > ago(^days, "day") and token.sent_to == user.email,
+            select: user
+
+        {:ok, query}
+
+      :error ->
+        :error
+    end
+  end
+
+  defp days_for_context("confirm"), do: @confirm_validity_in_days
+  defp days_for_context("reset_password"), do: @reset_password_validity_in_days
+
+  @doc """
+  Checks if the token is valid and returns its underlying lookup query.
+
+  The query returns the user found by the token, if any.
+
+  This is used to validate requests to change the user
+  email. It is different from `verify_email_token_query/2` precisely because
+  `verify_email_token_query/2` validates the email has not changed, which is
+  the starting point by this function.
+
+  The given token is valid if it matches its hashed counterpart in the
+  database and if it has not expired (after @change_email_validity_in_days).
+  The context must always start with "change:".
+  """
+  def verify_change_email_token_query(token, "change:" <> _ = context) do
+    case Base.url_decode64(token, padding: false) do
+      {:ok, decoded_token} ->
+        hashed_token = :crypto.hash(@hash_algorithm, decoded_token)
+
+        query =
+          from token in by_token_and_context_query(hashed_token, context),
+            where: token.inserted_at > ago(@change_email_validity_in_days, "day")
+
+        {:ok, query}
+
+      :error ->
+        :error
+    end
+  end
+
+  @doc """
+  Returns the token struct for the given token value and context.
+  """
+  def by_token_and_context_query(token, context) do
+    from UserToken, where: [token: ^token, context: ^context]
+  end
+
+  @doc """
+  Gets all tokens for the given user for the given contexts.
+  """
+  def by_user_and_contexts_query(user, :all) do
+    from t in UserToken, where: t.user_id == ^user.id
+  end
+
+  def by_user_and_contexts_query(user, [_ | _] = contexts) do
+    from t in UserToken, where: t.user_id == ^user.id and t.context in ^contexts
+  end
+end

lib/nulla/activities.ex

@@ -0,0 +1,104 @@
+defmodule Nulla.Activities do
+  @moduledoc """
+  The Activities context.
+  """
+
+  import Ecto.Query, warn: false
+  alias Nulla.Repo
+
+  alias Nulla.Activities.Activity
+
+  @doc """
+  Returns the list of activities.
+
+  ## Examples
+
+      iex> list_activities()
+      [%Activity{}, ...]
+
+  """
+  def list_activities do
+    Repo.all(Activity)
+  end
+
+  @doc """
+  Gets a single activity.
+
+  Raises `Ecto.NoResultsError` if the Activity does not exist.
+
+  ## Examples
+
+      iex> get_activity!(123)
+      %Activity{}
+
+      iex> get_activity!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_activity!(id), do: Repo.get!(Activity, id)
+
+  @doc """
+  Creates a activity.
+
+  ## Examples
+
+      iex> create_activity(%{field: value})
+      {:ok, %Activity{}}
+
+      iex> create_activity(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_activity(attrs \\ %{}) do
+    %Activity{}
+    |> Activity.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a activity.
+
+  ## Examples
+
+      iex> update_activity(activity, %{field: new_value})
+      {:ok, %Activity{}}
+
+      iex> update_activity(activity, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_activity(%Activity{} = activity, attrs) do
+    activity
+    |> Activity.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a activity.
+
+  ## Examples
+
+      iex> delete_activity(activity)
+      {:ok, %Activity{}}
+
+      iex> delete_activity(activity)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_activity(%Activity{} = activity) do
+    Repo.delete(activity)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking activity changes.
+
+  ## Examples
+
+      iex> change_activity(activity)
+      %Ecto.Changeset{data: %Activity{}}
+
+  """
+  def change_activity(%Activity{} = activity, attrs \\ %{}) do
+    Activity.changeset(activity, attrs)
+  end
+end

lib/nulla/activities/activity.ex

@@ -0,0 +1,34 @@
+defmodule Nulla.Activities.Activity do
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Ecto.Changeset
+  alias Nulla.Snowflake
+  alias Nulla.Types.StringOrJson
+
+  @derive {Jason.Encoder, only: [:ap_id, :type, :actor, :object]}
+  @primary_key {:id, :integer, autogenerate: false}
+  schema "activities" do
+    field :ap_id, :string
+    field :type, :string
+    field :actor, :string
+    field :object, StringOrJson
+    field :to, {:array, :string}
+    field :cc, {:array, :string}
+
+    timestamps(type: :utc_datetime)
+  end
+
+  @doc false
+  def changeset(activity, attrs) do
+    activity
+    |> cast(attrs, [:ap_id, :type, :actor, :object, :to, :cc])
+    |> maybe_put_id()
+    |> validate_required([:ap_id, :type, :actor, :object])
+  end
+
+  defp maybe_put_id(%Changeset{data: %{id: nil}} = changeset) do
+    change(changeset, id: Snowflake.next_id())
+  end
+
+  defp maybe_put_id(changeset), do: changeset
+end

lib/nulla/actors.ex

@@ -0,0 +1,104 @@
+defmodule Nulla.Actors do
+  @moduledoc """
+  The Actors context.
+  """
+
+  import Ecto.Query, warn: false
+  alias Nulla.Repo
+
+  alias Nulla.Actors.Actor
+
+  @doc """
+  Returns the list of actors.
+
+  ## Examples
+
+      iex> list_actors()
+      [%Actor{}, ...]
+
+  """
+  def list_actors do
+    Repo.all(Actor)
+  end
+
+  @doc """
+  Gets a single actor.
+
+  Raises `Ecto.NoResultsError` if the Actor does not exist.
+
+  ## Examples
+
+      iex> get_actor!(123)
+      %Actor{}
+
+      iex> get_actor!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_actor!(id), do: Repo.get!(Actor, id)
+
+  @doc """
+  Creates a actor.
+
+  ## Examples
+
+      iex> create_actor(%{field: value})
+      {:ok, %Actor{}}
+
+      iex> create_actor(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_actor(attrs \\ %{}) do
+    %Actor{}
+    |> Actor.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a actor.
+
+  ## Examples
+
+      iex> update_actor(actor, %{field: new_value})
+      {:ok, %Actor{}}
+
+      iex> update_actor(actor, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_actor(%Actor{} = actor, attrs) do
+    actor
+    |> Actor.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a actor.
+
+  ## Examples
+
+      iex> delete_actor(actor)
+      {:ok, %Actor{}}
+
+      iex> delete_actor(actor)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_actor(%Actor{} = actor) do
+    Repo.delete(actor)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking actor changes.
+
+  ## Examples
+
+      iex> change_actor(actor)
+      %Ecto.Changeset{data: %Actor{}}
+
+  """
+  def change_actor(%Actor{} = actor, attrs \\ %{}) do
+    Actor.changeset(actor, attrs)
+  end
+end

lib/nulla/actors/actor.ex

@@ -0,0 +1,95 @@
+defmodule Nulla.Actors.Actor do
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Ecto.Changeset
+  alias Nulla.Snowflake
+
+  @primary_key {:id, :integer, autogenerate: false}
+  schema "actors" do
+    field :acct, :string
+    field :ap_id, :string
+    field :type, :string
+    field :following, :string
+    field :followers, :string
+    field :inbox, :string
+    field :outbox, :string
+    field :featured, :string
+    field :featuredTags, :string
+    field :preferredUsername, :string
+    field :name, :string
+    field :summary, :string
+    field :url, :string
+    field :manuallyApprovesFollowers, :boolean, default: false
+    field :discoverable, :boolean, default: true
+    field :indexable, :boolean, default: true
+    field :published, :utc_datetime
+    field :memorial, :boolean, default: false
+    field :publicKey, :map
+    field :privateKeyPem, :string
+    field :tag, {:array, :map}, default: []
+    field :attachment, {:array, :map}, default: []
+    field :endpoints, :map
+    field :icon, :map
+    field :image, :map
+    field :vcard_bday, :date
+    field :vcard_Address, :string
+
+    timestamps(type: :utc_datetime)
+  end
+
+  @doc false
+  def changeset(actor, attrs) do
+    actor
+    |> cast(attrs, [
+      :acct,
+      :ap_id,
+      :type,
+      :following,
+      :followers,
+      :inbox,
+      :outbox,
+      :featured,
+      :featuredTags,
+      :preferredUsername,
+      :name,
+      :summary,
+      :url,
+      :manuallyApprovesFollowers,
+      :discoverable,
+      :indexable,
+      :published,
+      :memorial,
+      :publicKey,
+      :privateKeyPem,
+      :tag,
+      :attachment,
+      :endpoints,
+      :icon,
+      :image,
+      :vcard_bday,
+      :vcard_Address
+    ])
+    |> maybe_put_id()
+    |> validate_required([
+      :acct,
+      :ap_id,
+      :type,
+      :following,
+      :followers,
+      :inbox,
+      :outbox,
+      :featured,
+      :featuredTags,
+      :preferredUsername,
+      :url,
+      :publicKey,
+      :endpoints
+    ])
+  end
+
+  defp maybe_put_id(%Changeset{data: %{id: nil}} = changeset) do
+    change(changeset, id: Snowflake.next_id())
+  end
+
+  defp maybe_put_id(changeset), do: changeset
+end

lib/nulla/application.ex

@@ -7,6 +7,8 @@ defmodule Nulla.Application do
 
   @impl true
   def start(_type, _args) do
+    worker_id = Application.fetch_env!(:nulla, :snowflake)[:worker_id]
+
     children = [
       NullaWeb.Telemetry,
       Nulla.Repo,
@@ -17,7 +19,8 @@ defmodule Nulla.Application do
       # Start a worker by calling: Nulla.Worker.start_link(arg)
       # {Nulla.Worker, arg},
       # Start to serve requests, typically the last entry
-      NullaWeb.Endpoint
+      NullaWeb.Endpoint,
+      {Nulla.Snowflake, worker_id}
     ]
 
     # See https://hexdocs.pm/elixir/Supervisor.html

lib/nulla/http_signature.ex

@@ -0,0 +1,111 @@
+defmodule Nulla.HTTPSignature do
+  import Plug.Conn
+
+  def make_headers(body, inbox_url, publicKeyId, privateKeyPem) do
+    digest = "SHA-256=" <> (:crypto.hash(:sha256, body) |> Base.encode64())
+    date = DateTime.utc_now() |> Calendar.strftime("%a, %d %b %Y %H:%M:%S GMT")
+    uri = URI.parse(inbox_url)
+
+    signature_string =
+      "(request-target): post #{uri.path}\n" <>
+        "host: #{uri.host}\n" <>
+        "date: #{date}\n" <>
+        "digest: #{digest}"
+
+    private_key =
+      case :public_key.pem_decode(privateKeyPem) do
+        [entry] -> :public_key.pem_entry_decode(entry)
+        _ -> raise "Invalid PEM format"
+      end
+
+    signature =
+      :public_key.sign(signature_string, :sha256, private_key)
+      |> Base.encode64()
+
+    signature_header =
+      """
+      keyId="#{publicKeyId}",
+      algorithm="rsa-sha256",
+      headers="(request-target) host date digest",
+      signature="#{signature}"
+      """
+      |> String.replace("\n", "")
+      |> String.trim()
+
+    [
+      {"Content-Type", "application/activity+json"},
+      {"Date", date},
+      {"Digest", digest},
+      {"Signature", signature_header}
+    ]
+  end
+
+  def verify(conn, public_key_pem) do
+    with [sig_header] <- get_req_header(conn, "signature"),
+         signature_map <- parse_signature_header(sig_header),
+         {:ok, signed_string} <- build_signature_string(signature_map["headers"], conn),
+         true <- verify_signature(public_key_pem, signed_string, signature_map["signature"]) do
+      :ok
+    else
+      _ -> {:error, :invalid_signature}
+    end
+  end
+
+  defp parse_signature_header(header) do
+    header =
+      header
+      |> String.split(",")
+      |> Enum.map(fn pair ->
+        [k, v] = String.split(pair, "=", parts: 2)
+        {String.trim(k), String.trim(v, ~s("))}
+      end)
+      |> Enum.into(%{})
+
+    header
+  end
+
+  defp build_signature_string(nil, _conn), do: {:error, :missing_headers}
+
+  defp build_signature_string(headers_str, conn) do
+    headers = String.split(headers_str, " ")
+
+    result =
+      Enum.map(headers, fn header ->
+        line =
+          case header do
+            "(request-target)" ->
+              method = String.downcase(conn.method)
+
+              path =
+                conn.request_path <>
+                  if conn.query_string != "", do: "?" <> conn.query_string, else: ""
+
+              "(request-target): #{method} #{path}"
+
+            "host" ->
+              "host: #{conn.host}"
+
+            _ ->
+              value = get_req_header(conn, header) |> List.first()
+              if value, do: "#{header}: #{value}", else: nil
+          end
+
+        line
+      end)
+      |> Enum.reject(&is_nil/1)
+      |> Enum.join("\n")
+
+    {:ok, result}
+  end
+
+  defp verify_signature(public_key_pem, signed_string, signature_base64) do
+    public_key =
+      :public_key.pem_decode(public_key_pem)
+      |> hd()
+      |> :public_key.pem_entry_decode()
+
+    signature = Base.decode64!(signature_base64)
+
+    :public_key.verify(signed_string, :sha256, signature, public_key)
+  end
+end

lib/nulla/key_gen.ex

@@ -0,0 +1,24 @@
+defmodule Nulla.KeyGen do
+  def gen do
+    key = :public_key.generate_key({:rsa, 2048, 65_537})
+    entry = :public_key.pem_entry_encode(:RSAPrivateKey, key)
+
+    private_pem =
+      :public_key.pem_encode([entry])
+      |> String.trim_trailing()
+      |> Kernel.<>("\n")
+
+    [private_key_code] = :public_key.pem_decode(private_pem)
+    private_key = :public_key.pem_entry_decode(private_key_code)
+    {:RSAPrivateKey, _, modulus, exponent, _, _, _, _, _, _, _} = private_key
+    public_key = {:RSAPublicKey, modulus, exponent}
+    public_key = :public_key.pem_entry_encode(:SubjectPublicKeyInfo, public_key)
+
+    public_pem =
+      :public_key.pem_encode([public_key])
+      |> String.trim_trailing()
+      |> Kernel.<>("\n")
+
+    {public_pem, private_pem}
+  end
+end

lib/nulla/media_attachments.ex

@@ -0,0 +1,104 @@
+defmodule Nulla.MediaAttachments do
+  @moduledoc """
+  The MediaAttachments context.
+  """
+
+  import Ecto.Query, warn: false
+  alias Nulla.Repo
+
+  alias Nulla.MediaAttachments.MediaAttachment
+
+  @doc """
+  Returns the list of media_attachments.
+
+  ## Examples
+
+      iex> list_media_attachments()
+      [%MediaAttachment{}, ...]
+
+  """
+  def list_media_attachments do
+    Repo.all(MediaAttachment)
+  end
+
+  @doc """
+  Gets a single media_attachment.
+
+  Raises `Ecto.NoResultsError` if the Media attachment does not exist.
+
+  ## Examples
+
+      iex> get_media_attachment!(123)
+      %MediaAttachment{}
+
+      iex> get_media_attachment!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_media_attachment!(id), do: Repo.get!(MediaAttachment, id)
+
+  @doc """
+  Creates a media_attachment.
+
+  ## Examples
+
+      iex> create_media_attachment(%{field: value})
+      {:ok, %MediaAttachment{}}
+
+      iex> create_media_attachment(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_media_attachment(attrs \\ %{}) do
+    %MediaAttachment{}
+    |> MediaAttachment.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a media_attachment.
+
+  ## Examples
+
+      iex> update_media_attachment(media_attachment, %{field: new_value})
+      {:ok, %MediaAttachment{}}
+
+      iex> update_media_attachment(media_attachment, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_media_attachment(%MediaAttachment{} = media_attachment, attrs) do
+    media_attachment
+    |> MediaAttachment.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a media_attachment.
+
+  ## Examples
+
+      iex> delete_media_attachment(media_attachment)
+      {:ok, %MediaAttachment{}}
+
+      iex> delete_media_attachment(media_attachment)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_media_attachment(%MediaAttachment{} = media_attachment) do
+    Repo.delete(media_attachment)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking media_attachment changes.
+
+  ## Examples
+
+      iex> change_media_attachment(media_attachment)
+      %Ecto.Changeset{data: %MediaAttachment{}}
+
+  """
+  def change_media_attachment(%MediaAttachment{} = media_attachment, attrs \\ %{}) do
+    MediaAttachment.changeset(media_attachment, attrs)
+  end
+end

lib/nulla/media_attachments/media_attachment.ex

@@ -0,0 +1,35 @@
+defmodule Nulla.MediaAttachments.MediaAttachment do
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Ecto.Changeset
+  alias Nulla.Snowflake
+  alias Nulla.Notes.Note
+
+  @primary_key {:id, :integer, autogenerate: false}
+  schema "media_attachments" do
+    field :type, :string
+    field :mediaType, :string
+    field :url, :string
+    field :name, :string
+    field :width, :integer
+    field :height, :integer
+
+    belongs_to :note, Note
+
+    timestamps(type: :utc_datetime)
+  end
+
+  @doc false
+  def changeset(media_attachment, attrs) do
+    media_attachment
+    |> cast(attrs, [:type, :mediaType, :url, :name, :width, :height, :note_id])
+    |> maybe_put_id()
+    |> validate_required([:type, :mediaType, :url, :note_id])
+  end
+
+  defp maybe_put_id(%Changeset{data: %{id: nil}} = changeset) do
+    change(changeset, id: Snowflake.next_id())
+  end
+
+  defp maybe_put_id(changeset), do: changeset
+end

lib/nulla/notes.ex

@@ -0,0 +1,104 @@
+defmodule Nulla.Notes do
+  @moduledoc """
+  The Notes context.
+  """
+
+  import Ecto.Query, warn: false
+  alias Nulla.Repo
+
+  alias Nulla.Notes.Note
+
+  @doc """
+  Returns the list of notes.
+
+  ## Examples
+
+      iex> list_notes()
+      [%Note{}, ...]
+
+  """
+  def list_notes do
+    Repo.all(Note)
+  end
+
+  @doc """
+  Gets a single note.
+
+  Raises `Ecto.NoResultsError` if the Note does not exist.
+
+  ## Examples
+
+      iex> get_note!(123)
+      %Note{}
+
+      iex> get_note!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_note!(id), do: Repo.get!(Note, id)
+
+  @doc """
+  Creates a note.
+
+  ## Examples
+
+      iex> create_note(%{field: value})
+      {:ok, %Note{}}
+
+      iex> create_note(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_note(attrs \\ %{}) do
+    %Note{}
+    |> Note.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a note.
+
+  ## Examples
+
+      iex> update_note(note, %{field: new_value})
+      {:ok, %Note{}}
+
+      iex> update_note(note, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_note(%Note{} = note, attrs) do
+    note
+    |> Note.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a note.
+
+  ## Examples
+
+      iex> delete_note(note)
+      {:ok, %Note{}}
+
+      iex> delete_note(note)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_note(%Note{} = note) do
+    Repo.delete(note)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking note changes.
+
+  ## Examples
+
+      iex> change_note(note)
+      %Ecto.Changeset{data: %Note{}}
+
+  """
+  def change_note(%Note{} = note, attrs \\ %{}) do
+    Note.changeset(note, attrs)
+  end
+end

lib/nulla/notes/note.ex

@@ -0,0 +1,60 @@
+defmodule Nulla.Notes.Note do
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Ecto.Changeset
+  alias Nulla.Snowflake
+  alias Nulla.Actors.Actor
+  alias Nulla.MediaAttachments.MediaAttachment
+
+  @primary_key {:id, :integer, autogenerate: false}
+  schema "notes" do
+    field :inReplyTo, :string
+    field :published, :utc_datetime
+    field :url, :string
+    field :visibility, :string
+    field :to, {:array, :string}
+    field :cc, {:array, :string}
+    field :sensitive, :boolean, default: false
+    field :content, :string
+    field :language, :string
+
+    belongs_to :actor, Actor
+    has_many :media_attachments, MediaAttachment
+
+    timestamps(type: :utc_datetime)
+  end
+
+  @doc false
+  def changeset(note, attrs) do
+    note
+    |> cast(attrs, [
+      :inReplyTo,
+      :published,
+      :url,
+      :visibility,
+      :to,
+      :cc,
+      :sensitive,
+      :content,
+      :language,
+      :actor_id
+    ])
+    |> maybe_put_id()
+    |> validate_required([
+      :published,
+      :url,
+      :visibility,
+      :to,
+      :cc,
+      :content,
+      :language,
+      :actor_id
+    ])
+  end
+
+  defp maybe_put_id(%Changeset{data: %{id: nil}} = changeset) do
+    change(changeset, id: Snowflake.next_id())
+  end
+
+  defp maybe_put_id(changeset), do: changeset
+end

lib/nulla/relations.ex

@@ -0,0 +1,104 @@
+defmodule Nulla.Relations do
+  @moduledoc """
+  The Relations context.
+  """
+
+  import Ecto.Query, warn: false
+  alias Nulla.Repo
+
+  alias Nulla.Relations.Relation
+
+  @doc """
+  Returns the list of relations.
+
+  ## Examples
+
+      iex> list_relations()
+      [%Relation{}, ...]
+
+  """
+  def list_relations do
+    Repo.all(Relation)
+  end
+
+  @doc """
+  Gets a single relation.
+
+  Raises `Ecto.NoResultsError` if the Relation does not exist.
+
+  ## Examples
+
+      iex> get_relation!(123)
+      %Relation{}
+
+      iex> get_relation!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_relation!(id), do: Repo.get!(Relation, id)
+
+  @doc """
+  Creates a relation.
+
+  ## Examples
+
+      iex> create_relation(%{field: value})
+      {:ok, %Relation{}}
+
+      iex> create_relation(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_relation(attrs \\ %{}) do
+    %Relation{}
+    |> Relation.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a relation.
+
+  ## Examples
+
+      iex> update_relation(relation, %{field: new_value})
+      {:ok, %Relation{}}
+
+      iex> update_relation(relation, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_relation(%Relation{} = relation, attrs) do
+    relation
+    |> Relation.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a relation.
+
+  ## Examples
+
+      iex> delete_relation(relation)
+      {:ok, %Relation{}}
+
+      iex> delete_relation(relation)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_relation(%Relation{} = relation) do
+    Repo.delete(relation)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking relation changes.
+
+  ## Examples
+
+      iex> change_relation(relation)
+      %Ecto.Changeset{data: %Relation{}}
+
+  """
+  def change_relation(%Relation{} = relation, attrs \\ %{}) do
+    Relation.changeset(relation, attrs)
+  end
+end

lib/nulla/relations/relation.ex

@@ -0,0 +1,71 @@
+defmodule Nulla.Relations.Relation do
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Ecto.Changeset
+  alias Nulla.Snowflake
+  alias Nulla.Actors.Actor
+
+  schema "relations" do
+    field :following, :boolean, default: false
+    field :followed_by, :boolean, default: false
+    field :showing_replies, :boolean, default: true
+    field :showings_reblogs, :boolean, default: true
+    field :notifying, :boolean, default: false
+    field :muting, :boolean, default: false
+    field :muting_notifications, :boolean, default: false
+    field :blocking, :boolean, default: false
+    field :blocked_by, :boolean, default: false
+    field :domain_blocking, :boolean, default: false
+    field :requested, :boolean, default: false
+    field :note, :string
+
+    belongs_to :local_actor, Actor
+    belongs_to :remote_actor, Actor
+
+    timestamps(type: :utc_datetime)
+  end
+
+  @doc false
+  def changeset(relation, attrs) do
+    relation
+    |> cast(attrs, [
+      :following,
+      :followed_by,
+      :showing_replies,
+      :showings_reblogs,
+      :notifying,
+      :muting,
+      :muting_notifications,
+      :blocking,
+      :blocked_by,
+      :domain_blocking,
+      :requested,
+      :note,
+      :local_actor_id,
+      :remote_actor_id
+    ])
+    |> maybe_put_id()
+    |> validate_required([
+      :following,
+      :followed_by,
+      :showing_replies,
+      :showings_reblogs,
+      :notifying,
+      :muting,
+      :muting_notifications,
+      :blocking,
+      :blocked_by,
+      :domain_blocking,
+      :requested,
+      :note,
+      :local_actor_id,
+      :remote_actor_id
+    ])
+  end
+
+  defp maybe_put_id(%Changeset{data: %{id: nil}} = changeset) do
+    change(changeset, id: Snowflake.next_id())
+  end
+
+  defp maybe_put_id(changeset), do: changeset
+end

lib/nulla/sender.ex

@@ -0,0 +1,24 @@
+defmodule Nulla.Sender do
+  alias Nulla.HTTPSignature
+  alias NullaWeb.ActivityJSON
+
+  def send_activity(method, inbox, activity, publicKeyId, privateKeyPem) do
+    body = Jason.encode!(ActivityJSON.activitypub(activity))
+    headers = HTTPSignature.make_headers(body, inbox, publicKeyId, privateKeyPem)
+    request = Finch.build(method, inbox, headers, body)
+
+    case Finch.request(request, Nulla.Finch) do
+      {:ok, %Finch.Response{status: code}} when code in 200..299 ->
+        IO.puts("Activity #{activity.id} delivered successfully")
+        :ok
+
+      {:ok, %Finch.Response{status: code, body: resp}} ->
+        IO.inspect({:error, code, resp}, label: "Failed to deliver activity #{activity.id}")
+        {:error, {:http_error, code}}
+
+      {:error, reason} ->
+        IO.inspect(reason, label: "Activity #{activity.id} delivery failed")
+        {:error, reason}
+    end
+  end
+end

lib/nulla/snowflake.ex

@@ -0,0 +1,62 @@
+defmodule Nulla.Snowflake do
+  use GenServer
+  import Bitwise
+
+  @epoch :calendar.datetime_to_gregorian_seconds({{2020, 1, 1}, {0, 0, 0}}) * 1000
+  @max_sequence 4095
+  @time_shift 22
+  @worker_shift 12
+
+  def start_link(worker_id) when worker_id in 0..1023 do
+    GenServer.start_link(__MODULE__, worker_id, name: __MODULE__)
+  end
+
+  def next_id do
+    GenServer.call(__MODULE__, :next_id)
+  end
+
+  @impl true
+  def init(worker_id) do
+    {:ok, %{last_timestamp: -1, sequence: 0, worker_id: worker_id}}
+  end
+
+  @impl true
+  def handle_call(:next_id, _from, %{worker_id: worker_id} = state) do
+    timestamp = current_time()
+
+    {timestamp, sequence, state} =
+      cond do
+        timestamp < state.last_timestamp ->
+          raise "Clock moved backwards"
+
+        timestamp == state.last_timestamp and state.sequence < @max_sequence ->
+          {timestamp, state.sequence + 1, %{state | sequence: state.sequence + 1}}
+
+        timestamp == state.last_timestamp ->
+          wait_for_next_millisecond(timestamp)
+          new_timestamp = current_time()
+          {new_timestamp, 0, %{state | last_timestamp: new_timestamp, sequence: 0}}
+
+        true ->
+          {timestamp, 0, %{state | last_timestamp: timestamp, sequence: 0}}
+      end
+
+    raw_id =
+      ((timestamp - @epoch) <<< @time_shift)
+      |> bor(worker_id <<< @worker_shift)
+      |> bor(sequence)
+
+    id = Bitwise.band(raw_id, 0x7FFFFFFFFFFFFFFF)
+
+    {:reply, id, %{state | last_timestamp: timestamp, sequence: sequence}}
+  end
+
+  defp current_time do
+    System.system_time(:millisecond)
+  end
+
+  defp wait_for_next_millisecond(last_ts) do
+    :timer.sleep(1)
+    if current_time() <= last_ts, do: wait_for_next_millisecond(last_ts), else: :ok
+  end
+end

lib/nulla/types/string_or_json.ex

@@ -0,0 +1,46 @@
+defmodule Nulla.Types.StringOrJson do
+  @behaviour Ecto.Type
+
+  @impl true
+  def type, do: :string
+
+  @impl true
+  def cast(value) when is_map(value) or is_list(value), do: {:ok, value}
+
+  @impl true
+  def cast(value) when is_binary(value) do
+    case Jason.decode(value) do
+      {:ok, decoded} -> {:ok, decoded}
+      _ -> {:ok, value}
+    end
+  end
+
+  @impl true
+  def cast(_), do: :error
+
+  @impl true
+  def dump(value) when is_map(value) or is_list(value), do: Jason.encode(value)
+
+  @impl true
+  def dump(value) when is_binary(value), do: {:ok, value}
+
+  @impl true
+  def dump(_), do: :error
+
+  @impl true
+  def load(value) when is_binary(value) do
+    case Jason.decode(value) do
+      {:ok, decoded} -> {:ok, decoded}
+      _ -> {:ok, value}
+    end
+  end
+
+  @impl true
+  def load(_), do: :error
+
+  @impl true
+  def embed_as(_format), do: :self
+
+  @impl true
+  def equal?(term1, term2), do: term1 == term2
+end

lib/nulla_web/components/layouts/root.html.heex

@@ -12,6 +12,47 @@
     </script>
   </head>
   <body class="bg-white">
+    <ul class="relative z-10 flex items-center gap-4 px-4 sm:px-6 lg:px-8 justify-end">
+      <%= if @current_user do %>
+        <li class="text-[0.8125rem] leading-6 text-zinc-900">
+          {@current_user.email}
+        </li>
+        <li>
+          <.link
+            href={~p"/users/settings"}
+            class="text-[0.8125rem] leading-6 text-zinc-900 font-semibold hover:text-zinc-700"
+          >
+            Settings
+          </.link>
+        </li>
+        <li>
+          <.link
+            href={~p"/users/log_out"}
+            method="delete"
+            class="text-[0.8125rem] leading-6 text-zinc-900 font-semibold hover:text-zinc-700"
+          >
+            Log out
+          </.link>
+        </li>
+      <% else %>
+        <li>
+          <.link
+            href={~p"/users/register"}
+            class="text-[0.8125rem] leading-6 text-zinc-900 font-semibold hover:text-zinc-700"
+          >
+            Register
+          </.link>
+        </li>
+        <li>
+          <.link
+            href={~p"/users/log_in"}
+            class="text-[0.8125rem] leading-6 text-zinc-900 font-semibold hover:text-zinc-700"
+          >
+            Log in
+          </.link>
+        </li>
+      <% end %>
+    </ul>
     {@inner_content}
   </body>
 </html>

lib/nulla_web/controllers/activity_controller.ex

@@ -0,0 +1,43 @@
+defmodule NullaWeb.ActivityController do
+  use NullaWeb, :controller
+
+  alias Nulla.Activities
+  alias Nulla.Activities.Activity
+
+  action_fallback NullaWeb.FallbackController
+
+  def index(conn, _params) do
+    activities = Activities.list_activities()
+    render(conn, :index, activities: activities)
+  end
+
+  def create(conn, %{"activity" => activity_params}) do
+    with {:ok, %Activity{} = activity} <- Activities.create_activity(activity_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", ~p"/api/activities/#{activity}")
+      |> render(:show, activity: activity)
+    end
+  end
+
+  def show(conn, %{"id" => id}) do
+    activity = Activities.get_activity!(id)
+    render(conn, :show, activity: activity)
+  end
+
+  def update(conn, %{"id" => id, "activity" => activity_params}) do
+    activity = Activities.get_activity!(id)
+
+    with {:ok, %Activity{} = activity} <- Activities.update_activity(activity, activity_params) do
+      render(conn, :show, activity: activity)
+    end
+  end
+
+  def delete(conn, %{"id" => id}) do
+    activity = Activities.get_activity!(id)
+
+    with {:ok, %Activity{}} <- Activities.delete_activity(activity) do
+      send_resp(conn, :no_content, "")
+    end
+  end
+end

lib/nulla_web/controllers/activity_json.ex

@@ -0,0 +1,41 @@
+defmodule NullaWeb.ActivityJSON do
+  alias Nulla.Activities.Activity
+
+  @doc """
+  Renders a list of activities.
+  """
+  def index(%{activities: activities}) do
+    %{data: for(activity <- activities, do: data(activity))}
+  end
+
+  @doc """
+  Renders a single activity.
+  """
+  def show(%{activity: activity}) do
+    %{data: data(activity)}
+  end
+
+  defp data(%Activity{} = activity) do
+    %{
+      id: activity.id,
+      ap_id: activity.ap_id,
+      type: activity.type,
+      actor: activity.actor,
+      object: activity.object,
+      to: activity.to,
+      cc: activity.cc
+    }
+  end
+
+  def activitypub(%Activity{} = activity) do
+    Jason.OrderedObject.new(
+      "@context": "https://www.w3.org/ns/activitystreams",
+      id: activity.ap_id,
+      type: activity.type,
+      actor: activity.actor,
+      object: activity.object,
+      to: activity.to,
+      cc: activity.cc
+    )
+  end
+end

lib/nulla_web/controllers/actor_controller.ex

@@ -0,0 +1,43 @@
+defmodule NullaWeb.ActorController do
+  use NullaWeb, :controller
+
+  alias Nulla.Actors
+  alias Nulla.Actors.Actor
+
+  action_fallback NullaWeb.FallbackController
+
+  def index(conn, _params) do
+    actors = Actors.list_actors()
+    render(conn, :index, actors: actors)
+  end
+
+  def create(conn, %{"actor" => actor_params}) do
+    with {:ok, %Actor{} = actor} <- Actors.create_actor(actor_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", ~p"/api/actors/#{actor}")
+      |> render(:show, actor: actor)
+    end
+  end
+
+  def show(conn, %{"id" => id}) do
+    actor = Actors.get_actor!(id)
+    render(conn, :show, actor: actor)
+  end
+
+  def update(conn, %{"id" => id, "actor" => actor_params}) do
+    actor = Actors.get_actor!(id)
+
+    with {:ok, %Actor{} = actor} <- Actors.update_actor(actor, actor_params) do
+      render(conn, :show, actor: actor)
+    end
+  end
+
+  def delete(conn, %{"id" => id}) do
+    actor = Actors.get_actor!(id)
+
+    with {:ok, %Actor{}} <- Actors.delete_actor(actor) do
+      send_resp(conn, :no_content, "")
+    end
+  end
+end

lib/nulla_web/controllers/actor_json.ex

@@ -0,0 +1,49 @@
+defmodule NullaWeb.ActorJSON do
+  alias Nulla.Actors.Actor
+
+  @doc """
+  Renders a list of actors.
+  """
+  def index(%{actors: actors}) do
+    %{data: for(actor <- actors, do: data(actor))}
+  end
+
+  @doc """
+  Renders a single actor.
+  """
+  def show(%{actor: actor}) do
+    %{data: data(actor)}
+  end
+
+  defp data(%Actor{} = actor) do
+    %{
+      id: actor.id,
+      acct: actor.acct,
+      ap_id: actor.ap_id,
+      type: actor.type,
+      following: actor.following,
+      followers: actor.followers,
+      inbox: actor.inbox,
+      outbox: actor.outbox,
+      featured: actor.featured,
+      featuredTags: actor.featuredTags,
+      preferredUsername: actor.preferredUsername,
+      name: actor.name,
+      summary: actor.summary,
+      url: actor.url,
+      manuallyApprovesFollowers: actor.manuallyApprovesFollowers,
+      discoverable: actor.discoverable,
+      indexable: actor.indexable,
+      published: actor.published,
+      memorial: actor.memorial,
+      publicKey: actor.publicKey,
+      tag: actor.tag,
+      attachment: actor.attachment,
+      endpoints: actor.endpoints,
+      icon: actor.icon,
+      image: actor.image,
+      vcard_bday: actor.vcard_bday,
+      vcard_Address: actor.vcard_Address
+    }
+  end
+end

lib/nulla_web/controllers/changeset_json.ex

@@ -0,0 +1,25 @@
+defmodule NullaWeb.ChangesetJSON do
+  @doc """
+  Renders changeset errors.
+  """
+  def error(%{changeset: changeset}) do
+    # When encoded, the changeset returns its errors
+    # as a JSON object. So we just pass it forward.
+    %{errors: Ecto.Changeset.traverse_errors(changeset, &translate_error/1)}
+  end
+
+  defp translate_error({msg, opts}) do
+    # You can make use of gettext to translate error messages by
+    # uncommenting and adjusting the following code:
+
+    # if count = opts[:count] do
+    #   Gettext.dngettext(NullaWeb.Gettext, "errors", msg, msg, count, opts)
+    # else
+    #   Gettext.dgettext(NullaWeb.Gettext, "errors", msg, opts)
+    # end
+
+    Enum.reduce(opts, msg, fn {key, value}, acc ->
+      String.replace(acc, "%{#{key}}", fn _ -> to_string(value) end)
+    end)
+  end
+end

lib/nulla_web/controllers/fallback_controller.ex

@@ -0,0 +1,24 @@
+defmodule NullaWeb.FallbackController do
+  @moduledoc """
+  Translates controller action results into valid `Plug.Conn` responses.
+
+  See `Phoenix.Controller.action_fallback/1` for more details.
+  """
+  use NullaWeb, :controller
+
+  # This clause handles errors returned by Ecto's insert/update/delete.
+  def call(conn, {:error, %Ecto.Changeset{} = changeset}) do
+    conn
+    |> put_status(:unprocessable_entity)
+    |> put_view(json: NullaWeb.ChangesetJSON)
+    |> render(:error, changeset: changeset)
+  end
+
+  # This clause is an example of how to handle resources that cannot be found.
+  def call(conn, {:error, :not_found}) do
+    conn
+    |> put_status(:not_found)
+    |> put_view(html: NullaWeb.ErrorHTML, json: NullaWeb.ErrorJSON)
+    |> render(:"404")
+  end
+end

lib/nulla_web/controllers/media_attachment_controller.ex

@@ -0,0 +1,45 @@
+defmodule NullaWeb.MediaAttachmentController do
+  use NullaWeb, :controller
+
+  alias Nulla.MediaAttachments
+  alias Nulla.MediaAttachments.MediaAttachment
+
+  action_fallback NullaWeb.FallbackController
+
+  def index(conn, _params) do
+    media_attachments = MediaAttachments.list_media_attachments()
+    render(conn, :index, media_attachments: media_attachments)
+  end
+
+  def create(conn, %{"media_attachment" => media_attachment_params}) do
+    with {:ok, %MediaAttachment{} = media_attachment} <-
+           MediaAttachments.create_media_attachment(media_attachment_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", ~p"/api/media_attachments/#{media_attachment}")
+      |> render(:show, media_attachment: media_attachment)
+    end
+  end
+
+  def show(conn, %{"id" => id}) do
+    media_attachment = MediaAttachments.get_media_attachment!(id)
+    render(conn, :show, media_attachment: media_attachment)
+  end
+
+  def update(conn, %{"id" => id, "media_attachment" => media_attachment_params}) do
+    media_attachment = MediaAttachments.get_media_attachment!(id)
+
+    with {:ok, %MediaAttachment{} = media_attachment} <-
+           MediaAttachments.update_media_attachment(media_attachment, media_attachment_params) do
+      render(conn, :show, media_attachment: media_attachment)
+    end
+  end
+
+  def delete(conn, %{"id" => id}) do
+    media_attachment = MediaAttachments.get_media_attachment!(id)
+
+    with {:ok, %MediaAttachment{}} <- MediaAttachments.delete_media_attachment(media_attachment) do
+      send_resp(conn, :no_content, "")
+    end
+  end
+end

lib/nulla_web/controllers/media_attachment_json.ex

@@ -0,0 +1,29 @@
+defmodule NullaWeb.MediaAttachmentJSON do
+  alias Nulla.MediaAttachments.MediaAttachment
+
+  @doc """
+  Renders a list of media_attachments.
+  """
+  def index(%{media_attachments: media_attachments}) do
+    %{data: for(media_attachment <- media_attachments, do: data(media_attachment))}
+  end
+
+  @doc """
+  Renders a single media_attachment.
+  """
+  def show(%{media_attachment: media_attachment}) do
+    %{data: data(media_attachment)}
+  end
+
+  defp data(%MediaAttachment{} = media_attachment) do
+    %{
+      id: media_attachment.id,
+      type: media_attachment.type,
+      mediaType: media_attachment.mediaType,
+      url: media_attachment.url,
+      name: media_attachment.name,
+      width: media_attachment.width,
+      height: media_attachment.height
+    }
+  end
+end

lib/nulla_web/controllers/note_controller.ex

@@ -0,0 +1,43 @@
+defmodule NullaWeb.NoteController do
+  use NullaWeb, :controller
+
+  alias Nulla.Notes
+  alias Nulla.Notes.Note
+
+  action_fallback NullaWeb.FallbackController
+
+  def index(conn, _params) do
+    notes = Notes.list_notes()
+    render(conn, :index, notes: notes)
+  end
+
+  def create(conn, %{"note" => note_params}) do
+    with {:ok, %Note{} = note} <- Notes.create_note(note_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", ~p"/api/notes/#{note}")
+      |> render(:show, note: note)
+    end
+  end
+
+  def show(conn, %{"id" => id}) do
+    note = Notes.get_note!(id)
+    render(conn, :show, note: note)
+  end
+
+  def update(conn, %{"id" => id, "note" => note_params}) do
+    note = Notes.get_note!(id)
+
+    with {:ok, %Note{} = note} <- Notes.update_note(note, note_params) do
+      render(conn, :show, note: note)
+    end
+  end
+
+  def delete(conn, %{"id" => id}) do
+    note = Notes.get_note!(id)
+
+    with {:ok, %Note{}} <- Notes.delete_note(note) do
+      send_resp(conn, :no_content, "")
+    end
+  end
+end

lib/nulla_web/controllers/note_json.ex

@@ -0,0 +1,32 @@
+defmodule NullaWeb.NoteJSON do
+  alias Nulla.Notes.Note
+
+  @doc """
+  Renders a list of notes.
+  """
+  def index(%{notes: notes}) do
+    %{data: for(note <- notes, do: data(note))}
+  end
+
+  @doc """
+  Renders a single note.
+  """
+  def show(%{note: note}) do
+    %{data: data(note)}
+  end
+
+  defp data(%Note{} = note) do
+    %{
+      id: note.id,
+      inReplyTo: note.inReplyTo,
+      published: note.published,
+      url: note.url,
+      visibility: note.visibility,
+      to: note.to,
+      cc: note.cc,
+      sensitive: note.sensitive,
+      content: note.content,
+      language: note.language
+    }
+  end
+end

lib/nulla_web/controllers/relation_controller.ex

@@ -0,0 +1,43 @@
+defmodule NullaWeb.RelationController do
+  use NullaWeb, :controller
+
+  alias Nulla.Relations
+  alias Nulla.Relations.Relation
+
+  action_fallback NullaWeb.FallbackController
+
+  def index(conn, _params) do
+    relations = Relations.list_relations()
+    render(conn, :index, relations: relations)
+  end
+
+  def create(conn, %{"relation" => relation_params}) do
+    with {:ok, %Relation{} = relation} <- Relations.create_relation(relation_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", ~p"/api/relations/#{relation}")
+      |> render(:show, relation: relation)
+    end
+  end
+
+  def show(conn, %{"id" => id}) do
+    relation = Relations.get_relation!(id)
+    render(conn, :show, relation: relation)
+  end
+
+  def update(conn, %{"id" => id, "relation" => relation_params}) do
+    relation = Relations.get_relation!(id)
+
+    with {:ok, %Relation{} = relation} <- Relations.update_relation(relation, relation_params) do
+      render(conn, :show, relation: relation)
+    end
+  end
+
+  def delete(conn, %{"id" => id}) do
+    relation = Relations.get_relation!(id)
+
+    with {:ok, %Relation{}} <- Relations.delete_relation(relation) do
+      send_resp(conn, :no_content, "")
+    end
+  end
+end

lib/nulla_web/controllers/relation_json.ex

@@ -0,0 +1,35 @@
+defmodule NullaWeb.RelationJSON do
+  alias Nulla.Relations.Relation
+
+  @doc """
+  Renders a list of relations.
+  """
+  def index(%{relations: relations}) do
+    %{data: for(relation <- relations, do: data(relation))}
+  end
+
+  @doc """
+  Renders a single relation.
+  """
+  def show(%{relation: relation}) do
+    %{data: data(relation)}
+  end
+
+  defp data(%Relation{} = relation) do
+    %{
+      id: relation.id,
+      following: relation.following,
+      followed_by: relation.followed_by,
+      showing_replies: relation.showing_replies,
+      showings_reblogs: relation.showings_reblogs,
+      notifying: relation.notifying,
+      muting: relation.muting,
+      muting_notifications: relation.muting_notifications,
+      blocking: relation.blocking,
+      blocked_by: relation.blocked_by,
+      domain_blocking: relation.domain_blocking,
+      requested: relation.requested,
+      note: relation.note
+    }
+  end
+end

lib/nulla_web/controllers/user_session_controller.ex

@@ -0,0 +1,42 @@
+defmodule NullaWeb.UserSessionController do
+  use NullaWeb, :controller
+
+  alias Nulla.Accounts
+  alias NullaWeb.UserAuth
+
+  def create(conn, %{"_action" => "registered"} = params) do
+    create(conn, params, "Account created successfully!")
+  end
+
+  def create(conn, %{"_action" => "password_updated"} = params) do
+    conn
+    |> put_session(:user_return_to, ~p"/users/settings")
+    |> create(params, "Password updated successfully!")
+  end
+
+  def create(conn, params) do
+    create(conn, params, "Welcome back!")
+  end
+
+  defp create(conn, %{"user" => user_params}, info) do
+    %{"email" => email, "password" => password} = user_params
+
+    if user = Accounts.get_user_by_email_and_password(email, password) do
+      conn
+      |> put_flash(:info, info)
+      |> UserAuth.log_in_user(user, user_params)
+    else
+      # In order to prevent user enumeration attacks, don't disclose whether the email is registered.
+      conn
+      |> put_flash(:error, "Invalid email or password")
+      |> put_flash(:email, String.slice(email, 0, 160))
+      |> redirect(to: ~p"/users/log_in")
+    end
+  end
+
+  def delete(conn, _params) do
+    conn
+    |> put_flash(:info, "Logged out successfully.")
+    |> UserAuth.log_out_user()
+  end
+end

lib/nulla_web/live/user_confirmation_instructions_live.ex

@@ -0,0 +1,51 @@
+defmodule NullaWeb.UserConfirmationInstructionsLive do
+  use NullaWeb, :live_view
+
+  alias Nulla.Accounts
+
+  def render(assigns) do
+    ~H"""
+    <div class="mx-auto max-w-sm">
+      <.header class="text-center">
+        No confirmation instructions received?
+        <:subtitle>We'll send a new confirmation link to your inbox</:subtitle>
+      </.header>
+
+      <.simple_form for={@form} id="resend_confirmation_form" phx-submit="send_instructions">
+        <.input field={@form[:email]} type="email" placeholder="Email" required />
+        <:actions>
+          <.button phx-disable-with="Sending..." class="w-full">
+            Resend confirmation instructions
+          </.button>
+        </:actions>
+      </.simple_form>
+
+      <p class="text-center mt-4">
+        <.link href={~p"/users/register"}>Register</.link>
+        | <.link href={~p"/users/log_in"}>Log in</.link>
+      </p>
+    </div>
+    """
+  end
+
+  def mount(_params, _session, socket) do
+    {:ok, assign(socket, form: to_form(%{}, as: "user"))}
+  end
+
+  def handle_event("send_instructions", %{"user" => %{"email" => email}}, socket) do
+    if user = Accounts.get_user_by_email(email) do
+      Accounts.deliver_user_confirmation_instructions(
+        user,
+        &url(~p"/users/confirm/#{&1}")
+      )
+    end
+
+    info =
+      "If your email is in our system and it has not been confirmed yet, you will receive an email with instructions shortly."
+
+    {:noreply,
+     socket
+     |> put_flash(:info, info)
+     |> redirect(to: ~p"/")}
+  end
+end

lib/nulla_web/live/user_confirmation_live.ex

@@ -0,0 +1,58 @@
+defmodule NullaWeb.UserConfirmationLive do
+  use NullaWeb, :live_view
+
+  alias Nulla.Accounts
+
+  def render(%{live_action: :edit} = assigns) do
+    ~H"""
+    <div class="mx-auto max-w-sm">
+      <.header class="text-center">Confirm Account</.header>
+
+      <.simple_form for={@form} id="confirmation_form" phx-submit="confirm_account">
+        <input type="hidden" name={@form[:token].name} value={@form[:token].value} />
+        <:actions>
+          <.button phx-disable-with="Confirming..." class="w-full">Confirm my account</.button>
+        </:actions>
+      </.simple_form>
+
+      <p class="text-center mt-4">
+        <.link href={~p"/users/register"}>Register</.link>
+        | <.link href={~p"/users/log_in"}>Log in</.link>
+      </p>
+    </div>
+    """
+  end
+
+  def mount(%{"token" => token}, _session, socket) do
+    form = to_form(%{"token" => token}, as: "user")
+    {:ok, assign(socket, form: form), temporary_assigns: [form: nil]}
+  end
+
+  # Do not log in the user after confirmation to avoid a
+  # leaked token giving the user access to the account.
+  def handle_event("confirm_account", %{"user" => %{"token" => token}}, socket) do
+    case Accounts.confirm_user(token) do
+      {:ok, _} ->
+        {:noreply,
+         socket
+         |> put_flash(:info, "User confirmed successfully.")
+         |> redirect(to: ~p"/")}
+
+      :error ->
+        # If there is a current user and the account was already confirmed,
+        # then odds are that the confirmation link was already visited, either
+        # by some automation or by the user themselves, so we redirect without
+        # a warning message.
+        case socket.assigns do
+          %{current_user: %{confirmed_at: confirmed_at}} when not is_nil(confirmed_at) ->
+            {:noreply, redirect(socket, to: ~p"/")}
+
+          %{} ->
+            {:noreply,
+             socket
+             |> put_flash(:error, "User confirmation link is invalid or it has expired.")
+             |> redirect(to: ~p"/")}
+        end
+    end
+  end
+end

lib/nulla_web/live/user_forgot_password_live.ex

@@ -0,0 +1,50 @@
+defmodule NullaWeb.UserForgotPasswordLive do
+  use NullaWeb, :live_view
+
+  alias Nulla.Accounts
+
+  def render(assigns) do
+    ~H"""
+    <div class="mx-auto max-w-sm">
+      <.header class="text-center">
+        Forgot your password?
+        <:subtitle>We'll send a password reset link to your inbox</:subtitle>
+      </.header>
+
+      <.simple_form for={@form} id="reset_password_form" phx-submit="send_email">
+        <.input field={@form[:email]} type="email" placeholder="Email" required />
+        <:actions>
+          <.button phx-disable-with="Sending..." class="w-full">
+            Send password reset instructions
+          </.button>
+        </:actions>
+      </.simple_form>
+      <p class="text-center text-sm mt-4">
+        <.link href={~p"/users/register"}>Register</.link>
+        | <.link href={~p"/users/log_in"}>Log in</.link>
+      </p>
+    </div>
+    """
+  end
+
+  def mount(_params, _session, socket) do
+    {:ok, assign(socket, form: to_form(%{}, as: "user"))}
+  end
+
+  def handle_event("send_email", %{"user" => %{"email" => email}}, socket) do
+    if user = Accounts.get_user_by_email(email) do
+      Accounts.deliver_user_reset_password_instructions(
+        user,
+        &url(~p"/users/reset_password/#{&1}")
+      )
+    end
+
+    info =
+      "If your email is in our system, you will receive instructions to reset your password shortly."
+
+    {:noreply,
+     socket
+     |> put_flash(:info, info)
+     |> redirect(to: ~p"/")}
+  end
+end

lib/nulla_web/live/user_login_live.ex

@@ -0,0 +1,43 @@
+defmodule NullaWeb.UserLoginLive do
+  use NullaWeb, :live_view
+
+  def render(assigns) do
+    ~H"""
+    <div class="mx-auto max-w-sm">
+      <.header class="text-center">
+        Log in to account
+        <:subtitle>
+          Don't have an account?
+          <.link navigate={~p"/users/register"} class="font-semibold text-brand hover:underline">
+            Sign up
+          </.link>
+          for an account now.
+        </:subtitle>
+      </.header>
+
+      <.simple_form for={@form} id="login_form" action={~p"/users/log_in"} phx-update="ignore">
+        <.input field={@form[:email]} type="email" label="Email" required />
+        <.input field={@form[:password]} type="password" label="Password" required />
+
+        <:actions>
+          <.input field={@form[:remember_me]} type="checkbox" label="Keep me logged in" />
+          <.link href={~p"/users/reset_password"} class="text-sm font-semibold">
+            Forgot your password?
+          </.link>
+        </:actions>
+        <:actions>
+          <.button phx-disable-with="Logging in..." class="w-full">
+            Log in <span aria-hidden="true">→</span>
+          </.button>
+        </:actions>
+      </.simple_form>
+    </div>
+    """
+  end
+
+  def mount(_params, _session, socket) do
+    email = Phoenix.Flash.get(socket.assigns.flash, :email)
+    form = to_form(%{"email" => email}, as: "user")
+    {:ok, assign(socket, form: form), temporary_assigns: [form: form]}
+  end
+end

lib/nulla_web/live/user_registration_live.ex

@@ -0,0 +1,87 @@
+defmodule NullaWeb.UserRegistrationLive do
+  use NullaWeb, :live_view
+
+  alias Nulla.Accounts
+  alias Nulla.Accounts.User
+
+  def render(assigns) do
+    ~H"""
+    <div class="mx-auto max-w-sm">
+      <.header class="text-center">
+        Register for an account
+        <:subtitle>
+          Already registered?
+          <.link navigate={~p"/users/log_in"} class="font-semibold text-brand hover:underline">
+            Log in
+          </.link>
+          to your account now.
+        </:subtitle>
+      </.header>
+
+      <.simple_form
+        for={@form}
+        id="registration_form"
+        phx-submit="save"
+        phx-change="validate"
+        phx-trigger-action={@trigger_submit}
+        action={~p"/users/log_in?_action=registered"}
+        method="post"
+      >
+        <.error :if={@check_errors}>
+          Oops, something went wrong! Please check the errors below.
+        </.error>
+
+        <.input field={@form[:email]} type="email" label="Email" required />
+        <.input field={@form[:password]} type="password" label="Password" required />
+
+        <:actions>
+          <.button phx-disable-with="Creating account..." class="w-full">Create an account</.button>
+        </:actions>
+      </.simple_form>
+    </div>
+    """
+  end
+
+  def mount(_params, _session, socket) do
+    changeset = Accounts.change_user_registration(%User{})
+
+    socket =
+      socket
+      |> assign(trigger_submit: false, check_errors: false)
+      |> assign_form(changeset)
+
+    {:ok, socket, temporary_assigns: [form: nil]}
+  end
+
+  def handle_event("save", %{"user" => user_params}, socket) do
+    case Accounts.register_user(user_params) do
+      {:ok, user} ->
+        {:ok, _} =
+          Accounts.deliver_user_confirmation_instructions(
+            user,
+            &url(~p"/users/confirm/#{&1}")
+          )
+
+        changeset = Accounts.change_user_registration(user)
+        {:noreply, socket |> assign(trigger_submit: true) |> assign_form(changeset)}
+
+      {:error, %Ecto.Changeset{} = changeset} ->
+        {:noreply, socket |> assign(check_errors: true) |> assign_form(changeset)}
+    end
+  end
+
+  def handle_event("validate", %{"user" => user_params}, socket) do
+    changeset = Accounts.change_user_registration(%User{}, user_params)
+    {:noreply, assign_form(socket, Map.put(changeset, :action, :validate))}
+  end
+
+  defp assign_form(socket, %Ecto.Changeset{} = changeset) do
+    form = to_form(changeset, as: "user")
+
+    if changeset.valid? do
+      assign(socket, form: form, check_errors: false)
+    else
+      assign(socket, form: form)
+    end
+  end
+end

lib/nulla_web/live/user_reset_password_live.ex

@@ -0,0 +1,89 @@
+defmodule NullaWeb.UserResetPasswordLive do
+  use NullaWeb, :live_view
+
+  alias Nulla.Accounts
+
+  def render(assigns) do
+    ~H"""
+    <div class="mx-auto max-w-sm">
+      <.header class="text-center">Reset Password</.header>
+
+      <.simple_form
+        for={@form}
+        id="reset_password_form"
+        phx-submit="reset_password"
+        phx-change="validate"
+      >
+        <.error :if={@form.errors != []}>
+          Oops, something went wrong! Please check the errors below.
+        </.error>
+
+        <.input field={@form[:password]} type="password" label="New password" required />
+        <.input
+          field={@form[:password_confirmation]}
+          type="password"
+          label="Confirm new password"
+          required
+        />
+        <:actions>
+          <.button phx-disable-with="Resetting..." class="w-full">Reset Password</.button>
+        </:actions>
+      </.simple_form>
+
+      <p class="text-center text-sm mt-4">
+        <.link href={~p"/users/register"}>Register</.link>
+        | <.link href={~p"/users/log_in"}>Log in</.link>
+      </p>
+    </div>
+    """
+  end
+
+  def mount(params, _session, socket) do
+    socket = assign_user_and_token(socket, params)
+
+    form_source =
+      case socket.assigns do
+        %{user: user} ->
+          Accounts.change_user_password(user)
+
+        _ ->
+          %{}
+      end
+
+    {:ok, assign_form(socket, form_source), temporary_assigns: [form: nil]}
+  end
+
+  # Do not log in the user after reset password to avoid a
+  # leaked token giving the user access to the account.
+  def handle_event("reset_password", %{"user" => user_params}, socket) do
+    case Accounts.reset_user_password(socket.assigns.user, user_params) do
+      {:ok, _} ->
+        {:noreply,
+         socket
+         |> put_flash(:info, "Password reset successfully.")
+         |> redirect(to: ~p"/users/log_in")}
+
+      {:error, changeset} ->
+        {:noreply, assign_form(socket, Map.put(changeset, :action, :insert))}
+    end
+  end
+
+  def handle_event("validate", %{"user" => user_params}, socket) do
+    changeset = Accounts.change_user_password(socket.assigns.user, user_params)
+    {:noreply, assign_form(socket, Map.put(changeset, :action, :validate))}
+  end
+
+  defp assign_user_and_token(socket, %{"token" => token}) do
+    if user = Accounts.get_user_by_reset_password_token(token) do
+      assign(socket, user: user, token: token)
+    else
+      socket
+      |> put_flash(:error, "Reset password link is invalid or it has expired.")
+      |> redirect(to: ~p"/")
+    end
+  end
+
+  defp assign_form(socket, %{} = source) do
+    assign(socket, :form, to_form(source, as: "user"))
+  end
+end

lib/nulla_web/live/user_settings_live.ex

@@ -0,0 +1,167 @@
+defmodule NullaWeb.UserSettingsLive do
+  use NullaWeb, :live_view
+
+  alias Nulla.Accounts
+
+  def render(assigns) do
+    ~H"""
+    <.header class="text-center">
+      Account Settings
+      <:subtitle>Manage your account email address and password settings</:subtitle>
+    </.header>
+
+    <div class="space-y-12 divide-y">
+      <div>
+        <.simple_form
+          for={@email_form}
+          id="email_form"
+          phx-submit="update_email"
+          phx-change="validate_email"
+        >
+          <.input field={@email_form[:email]} type="email" label="Email" required />
+          <.input
+            field={@email_form[:current_password]}
+            name="current_password"
+            id="current_password_for_email"
+            type="password"
+            label="Current password"
+            value={@email_form_current_password}
+            required
+          />
+          <:actions>
+            <.button phx-disable-with="Changing...">Change Email</.button>
+          </:actions>
+        </.simple_form>
+      </div>
+      <div>
+        <.simple_form
+          for={@password_form}
+          id="password_form"
+          action={~p"/users/log_in?_action=password_updated"}
+          method="post"
+          phx-change="validate_password"
+          phx-submit="update_password"
+          phx-trigger-action={@trigger_submit}
+        >
+          <input
+            name={@password_form[:email].name}
+            type="hidden"
+            id="hidden_user_email"
+            value={@current_email}
+          />
+          <.input field={@password_form[:password]} type="password" label="New password" required />
+          <.input
+            field={@password_form[:password_confirmation]}
+            type="password"
+            label="Confirm new password"
+          />
+          <.input
+            field={@password_form[:current_password]}
+            name="current_password"
+            type="password"
+            label="Current password"
+            id="current_password_for_password"
+            value={@current_password}
+            required
+          />
+          <:actions>
+            <.button phx-disable-with="Changing...">Change Password</.button>
+          </:actions>
+        </.simple_form>
+      </div>
+    </div>
+    """
+  end
+
+  def mount(%{"token" => token}, _session, socket) do
+    socket =
+      case Accounts.update_user_email(socket.assigns.current_user, token) do
+        :ok ->
+          put_flash(socket, :info, "Email changed successfully.")
+
+        :error ->
+          put_flash(socket, :error, "Email change link is invalid or it has expired.")
+      end
+
+    {:ok, push_navigate(socket, to: ~p"/users/settings")}
+  end
+
+  def mount(_params, _session, socket) do
+    user = socket.assigns.current_user
+    email_changeset = Accounts.change_user_email(user)
+    password_changeset = Accounts.change_user_password(user)
+
+    socket =
+      socket
+      |> assign(:current_password, nil)
+      |> assign(:email_form_current_password, nil)
+      |> assign(:current_email, user.email)
+      |> assign(:email_form, to_form(email_changeset))
+      |> assign(:password_form, to_form(password_changeset))
+      |> assign(:trigger_submit, false)
+
+    {:ok, socket}
+  end
+
+  def handle_event("validate_email", params, socket) do
+    %{"current_password" => password, "user" => user_params} = params
+
+    email_form =
+      socket.assigns.current_user
+      |> Accounts.change_user_email(user_params)
+      |> Map.put(:action, :validate)
+      |> to_form()
+
+    {:noreply, assign(socket, email_form: email_form, email_form_current_password: password)}
+  end
+
+  def handle_event("update_email", params, socket) do
+    %{"current_password" => password, "user" => user_params} = params
+    user = socket.assigns.current_user
+
+    case Accounts.apply_user_email(user, password, user_params) do
+      {:ok, applied_user} ->
+        Accounts.deliver_user_update_email_instructions(
+          applied_user,
+          user.email,
+          &url(~p"/users/settings/confirm_email/#{&1}")
+        )
+
+        info = "A link to confirm your email change has been sent to the new address."
+        {:noreply, socket |> put_flash(:info, info) |> assign(email_form_current_password: nil)}
+
+      {:error, changeset} ->
+        {:noreply, assign(socket, :email_form, to_form(Map.put(changeset, :action, :insert)))}
+    end
+  end
+
+  def handle_event("validate_password", params, socket) do
+    %{"current_password" => password, "user" => user_params} = params
+
+    password_form =
+      socket.assigns.current_user
+      |> Accounts.change_user_password(user_params)
+      |> Map.put(:action, :validate)
+      |> to_form()
+
+    {:noreply, assign(socket, password_form: password_form, current_password: password)}
+  end
+
+  def handle_event("update_password", params, socket) do
+    %{"current_password" => password, "user" => user_params} = params
+    user = socket.assigns.current_user
+
+    case Accounts.update_user_password(user, password, user_params) do
+      {:ok, user} ->
+        password_form =
+          user
+          |> Accounts.change_user_password(user_params)
+          |> to_form()
+
+        {:noreply, assign(socket, trigger_submit: true, password_form: password_form)}
+
+      {:error, changeset} ->
+        {:noreply, assign(socket, password_form: to_form(changeset))}
+    end
+  end
+end

lib/nulla_web/router.ex

@@ -1,6 +1,8 @@
 defmodule NullaWeb.Router do
   use NullaWeb, :router
 
+  import NullaWeb.UserAuth
+
   pipeline :browser do
     plug :accepts, ["html"]
     plug :fetch_session
@@ -8,10 +10,12 @@ defmodule NullaWeb.Router do
     plug :put_root_layout, html: {NullaWeb.Layouts, :root}
     plug :protect_from_forgery
     plug :put_secure_browser_headers
+    plug :fetch_current_user
   end
 
   pipeline :api do
     plug :accepts, ["json"]
+    plug :fetch_api_user
   end
 
   scope "/", NullaWeb do
@@ -20,10 +24,15 @@ defmodule NullaWeb.Router do
     get "/", PageController, :home
   end
 
-  # Other scopes may use custom stacks.
-  # scope "/api", NullaWeb do
-  #   pipe_through :api
-  # end
+  scope "/api", NullaWeb do
+    pipe_through :api
+
+    resources "/actors", ActorController, except: [:new, :edit]
+    resources "/notes", NoteController, except: [:new, :edit]
+    resources "/media_attachments", MediaAttachmentController, except: [:new, :edit]
+    resources "/relations", RelationController, except: [:new, :edit]
+    resources "/activities", ActivityController, except: [:new, :edit]
+  end
 
   # Enable LiveDashboard and Swoosh mailbox preview in development
   if Application.compile_env(:nulla, :dev_routes) do
@@ -41,4 +50,42 @@ defmodule NullaWeb.Router do
       forward "/mailbox", Plug.Swoosh.MailboxPreview
     end
   end
+
+  ## Authentication routes
+
+  scope "/", NullaWeb do
+    pipe_through [:browser, :redirect_if_user_is_authenticated]
+
+    live_session :redirect_if_user_is_authenticated,
+      on_mount: [{NullaWeb.UserAuth, :redirect_if_user_is_authenticated}] do
+      live "/users/register", UserRegistrationLive, :new
+      live "/users/log_in", UserLoginLive, :new
+      live "/users/reset_password", UserForgotPasswordLive, :new
+      live "/users/reset_password/:token", UserResetPasswordLive, :edit
+    end
+
+    post "/users/log_in", UserSessionController, :create
+  end
+
+  scope "/", NullaWeb do
+    pipe_through [:browser, :require_authenticated_user]
+
+    live_session :require_authenticated_user,
+      on_mount: [{NullaWeb.UserAuth, :ensure_authenticated}] do
+      live "/users/settings", UserSettingsLive, :edit
+      live "/users/settings/confirm_email/:token", UserSettingsLive, :confirm_email
+    end
+  end
+
+  scope "/", NullaWeb do
+    pipe_through [:browser]
+
+    delete "/users/log_out", UserSessionController, :delete
+
+    live_session :current_user,
+      on_mount: [{NullaWeb.UserAuth, :mount_current_user}] do
+      live "/users/confirm/:token", UserConfirmationLive, :edit
+      live "/users/confirm", UserConfirmationInstructionsLive, :new
+    end
+  end
 end

lib/nulla_web/user_auth.ex

@@ -0,0 +1,245 @@
+defmodule NullaWeb.UserAuth do
+  use NullaWeb, :verified_routes
+
+  import Plug.Conn
+  import Phoenix.Controller
+
+  alias Nulla.Accounts
+
+  # Make the remember me cookie valid for 60 days.
+  # If you want bump or reduce this value, also change
+  # the token expiry itself in UserToken.
+  @max_age 60 * 60 * 24 * 60
+  @remember_me_cookie "_nulla_web_user_remember_me"
+  @remember_me_options [sign: true, max_age: @max_age, same_site: "Lax"]
+
+  @doc """
+  Logs the user in.
+
+  It renews the session ID and clears the whole session
+  to avoid fixation attacks. See the renew_session
+  function to customize this behaviour.
+
+  It also sets a `:live_socket_id` key in the session,
+  so LiveView sessions are identified and automatically
+  disconnected on log out. The line can be safely removed
+  if you are not using LiveView.
+  """
+  def log_in_user(conn, user, params \\ %{}) do
+    token = Accounts.generate_user_session_token(user)
+    user_return_to = get_session(conn, :user_return_to)
+
+    conn
+    |> renew_session()
+    |> put_token_in_session(token)
+    |> maybe_write_remember_me_cookie(token, params)
+    |> redirect(to: user_return_to || signed_in_path(conn))
+  end
+
+  defp maybe_write_remember_me_cookie(conn, token, %{"remember_me" => "true"}) do
+    put_resp_cookie(conn, @remember_me_cookie, token, @remember_me_options)
+  end
+
+  defp maybe_write_remember_me_cookie(conn, _token, _params) do
+    conn
+  end
+
+  # This function renews the session ID and erases the whole
+  # session to avoid fixation attacks. If there is any data
+  # in the session you may want to preserve after log in/log out,
+  # you must explicitly fetch the session data before clearing
+  # and then immediately set it after clearing, for example:
+  #
+  #     defp renew_session(conn) do
+  #       preferred_locale = get_session(conn, :preferred_locale)
+  #
+  #       conn
+  #       |> configure_session(renew: true)
+  #       |> clear_session()
+  #       |> put_session(:preferred_locale, preferred_locale)
+  #     end
+  #
+  defp renew_session(conn) do
+    delete_csrf_token()
+
+    conn
+    |> configure_session(renew: true)
+    |> clear_session()
+  end
+
+  @doc """
+  Logs the user out.
+
+  It clears all session data for safety. See renew_session.
+  """
+  def log_out_user(conn) do
+    user_token = get_session(conn, :user_token)
+    user_token && Accounts.delete_user_session_token(user_token)
+
+    if live_socket_id = get_session(conn, :live_socket_id) do
+      NullaWeb.Endpoint.broadcast(live_socket_id, "disconnect", %{})
+    end
+
+    conn
+    |> renew_session()
+    |> delete_resp_cookie(@remember_me_cookie)
+    |> redirect(to: ~p"/")
+  end
+
+  @doc """
+  Authenticates the user by looking into the session
+  and remember me token.
+  """
+  def fetch_current_user(conn, _opts) do
+    {user_token, conn} = ensure_user_token(conn)
+    user = user_token && Accounts.get_user_by_session_token(user_token)
+    assign(conn, :current_user, user)
+  end
+
+  defp ensure_user_token(conn) do
+    if token = get_session(conn, :user_token) do
+      {token, conn}
+    else
+      conn = fetch_cookies(conn, signed: [@remember_me_cookie])
+
+      if token = conn.cookies[@remember_me_cookie] do
+        {token, put_token_in_session(conn, token)}
+      else
+        {nil, conn}
+      end
+    end
+  end
+
+  @doc """
+  Handles mounting and authenticating the current_user in LiveViews.
+
+  ## `on_mount` arguments
+
+    * `:mount_current_user` - Assigns current_user
+      to socket assigns based on user_token, or nil if
+      there's no user_token or no matching user.
+
+    * `:ensure_authenticated` - Authenticates the user from the session,
+      and assigns the current_user to socket assigns based
+      on user_token.
+      Redirects to login page if there's no logged user.
+
+    * `:redirect_if_user_is_authenticated` - Authenticates the user from the session.
+      Redirects to signed_in_path if there's a logged user.
+
+  ## Examples
+
+  Use the `on_mount` lifecycle macro in LiveViews to mount or authenticate
+  the current_user:
+
+      defmodule NullaWeb.PageLive do
+        use NullaWeb, :live_view
+
+        on_mount {NullaWeb.UserAuth, :mount_current_user}
+        ...
+      end
+
+  Or use the `live_session` of your router to invoke the on_mount callback:
+
+      live_session :authenticated, on_mount: [{NullaWeb.UserAuth, :ensure_authenticated}] do
+        live "/profile", ProfileLive, :index
+      end
+  """
+  def on_mount(:mount_current_user, _params, session, socket) do
+    {:cont, mount_current_user(socket, session)}
+  end
+
+  def on_mount(:ensure_authenticated, _params, session, socket) do
+    socket = mount_current_user(socket, session)
+
+    if socket.assigns.current_user do
+      {:cont, socket}
+    else
+      socket =
+        socket
+        |> Phoenix.LiveView.put_flash(:error, "You must log in to access this page.")
+        |> Phoenix.LiveView.redirect(to: ~p"/users/log_in")
+
+      {:halt, socket}
+    end
+  end
+
+  def on_mount(:redirect_if_user_is_authenticated, _params, session, socket) do
+    socket = mount_current_user(socket, session)
+
+    if socket.assigns.current_user do
+      {:halt, Phoenix.LiveView.redirect(socket, to: signed_in_path(socket))}
+    else
+      {:cont, socket}
+    end
+  end
+
+  defp mount_current_user(socket, session) do
+    Phoenix.Component.assign_new(socket, :current_user, fn ->
+      if user_token = session["user_token"] do
+        Accounts.get_user_by_session_token(user_token)
+      end
+    end)
+  end
+
+  @doc """
+  Used for routes that require the user to not be authenticated.
+  """
+  def redirect_if_user_is_authenticated(conn, _opts) do
+    if conn.assigns[:current_user] do
+      conn
+      |> redirect(to: signed_in_path(conn))
+      |> halt()
+    else
+      conn
+    end
+  end
+
+  @doc """
+  Used for routes that require the user to be authenticated.
+
+  If you want to enforce the user email is confirmed before
+  they use the application at all, here would be a good place.
+  """
+  def require_authenticated_user(conn, _opts) do
+    if conn.assigns[:current_user] do
+      conn
+    else
+      conn
+      |> put_flash(:error, "You must log in to access this page.")
+      |> maybe_store_return_to()
+      |> redirect(to: ~p"/users/log_in")
+      |> halt()
+    end
+  end
+
+  def fetch_api_user(conn, _opts) do
+    if Mix.env() != :test do
+      with ["Bearer " <> token] <- get_req_header(conn, "authorization"),
+           {:ok, user} <- Accounts.fetch_user_by_api_token(token) do
+        assign(conn, :current_user, user)
+      else
+        _ ->
+          conn
+          |> send_resp(:unauthorized, "No access for you")
+          |> halt()
+      end
+    else
+      conn
+    end
+  end
+
+  defp put_token_in_session(conn, token) do
+    conn
+    |> put_session(:user_token, token)
+    |> put_session(:live_socket_id, "users_sessions:#{Base.url_encode64(token)}")
+  end
+
+  defp maybe_store_return_to(%{method: "GET"} = conn) do
+    put_session(conn, :user_return_to, current_path(conn))
+  end
+
+  defp maybe_store_return_to(conn), do: conn
+
+  defp signed_in_path(_conn), do: ~p"/"
+end