Add `--json` to any of them for machine-readable output.

`<topic-id>` is the full UUID or a prefix of it, at least eight characters

long — the length the `topics` listing prints. A prefix that matches more

than one topic answers `ambiguous_id`; add more of the id and retry.

## Search the forum

The named `forum` commands carry no search flag yet, so search through

    end

  end

  @doc """

  `fetch_readable_topic/2`, except `id` may also be a prefix of the topic's

  UUID, at least eight characters long — the length the CLI listing prints.

  A prefix that matches exactly one readable topic resolves to it. One that

  matches several answers `{:error, :ambiguous}`, so the caller can tell the

  reader to bring more of the id rather than claiming the topic is gone.

  """

  def resolve_readable_topic(id, opts \\ []) when is_list(opts) do

    case cast_uuid(id) do

      {:ok, _uuid} -> fetch_readable_topic(id, opts)

      {:error, :not_found} -> resolve_topic_prefix(id, opts)

    end

  end

  # Hex and hyphens only, so the prefix cannot smuggle LIKE metacharacters.

  @topic_id_prefix ~r/^[0-9a-f]{8}[0-9a-f-]{0,27}$/i

  defp resolve_topic_prefix(id, opts) when is_binary(id) do

    if Regex.match?(@topic_id_prefix, id) do

      pattern = String.downcase(id) <> "%"

      from(t in Topic,

        join: f in subquery(readable_forums(opts)),

        on: f.id == t.forum_id,

        where: like(fragment("?::text", t.id), ^pattern) and is_nil(t.archived_at),

        limit: 2

      )

      |> Repo.all()

      |> case do

        [topic] -> {:ok, topic}

        [] -> {:error, :not_found}

        _several -> {:error, :ambiguous}

      end

    else

      {:error, :not_found}

    end

  end

  defp resolve_topic_prefix(_id, _opts), do: {:error, :not_found}

  @doc """

  One page of topics whose title or visible post bodies match `term`, newest

  activity first.

  end

  def show_topic(conn, %{"id" => id} = params) do

    case Forum.fetch_readable_topic(id, scope(conn)) do

    case Forum.resolve_readable_topic(id, scope(conn)) do

      {:ok, topic} -> render_topic(conn, topic, params["page"])

      {:error, :ambiguous} -> conflict(conn, "ambiguous_id")

      {:error, :not_found} -> not_found(conn)

    end

  end

  def create_post(conn, %{"topic_id" => topic_id, "body_text" => body_text} = params) do

    if valid_text?(body_text) do

      with {:ok, topic} <- Forum.fetch_readable_topic(topic_id, scope(conn)),

      with {:ok, topic} <- Forum.resolve_readable_topic(topic_id, scope(conn)),

           {:ok, post} <- Forum.create_post(topic, post_attrs(conn, params)) do

        conn |> put_status(:created) |> render(:post, post: post)

      else

        {:error, :not_found} -> not_found(conn)

        {:error, :ambiguous} -> conflict(conn, "ambiguous_id")

        _closed -> conflict(conn, "topic_closed")

      end

    else

    assert [%{"body_text" => "First post body"}] = posts

  end

  # A topic whose id the test chooses, so a prefix can be shared or unique on

  # purpose. Inserted without posts; resolution is what these tests read.

  defp topic_with_id(forum, id) do

    {:ok, topic} =

      %Forum.Topic{}

      |> Ecto.Changeset.change(%{

        id: id,

        forum_id: forum.id,

        idempotency_key: Ecto.UUID.generate(),

        slug: "topic-#{System.unique_integer([:positive])}",

        title: "Prefixed topic",

        actor_ref: "agent:agent_artanis",

        actor_display_name: "Artanis"

      })

      |> Repo.insert()

    topic

  end

  test "GET /api/v1/forum/topics/:id resolves a unique id prefix", %{conn: conn, forum: forum} do

    topic = topic_with_id(forum, "aaaabbbb-0000-4000-8000-000000000001")

    conn = get(conn, ~p"/api/v1/forum/topics/aaaabbbb")

    assert %{"topic" => t} = json_response(conn, 200)

    assert t["id"] == topic.id

  end

  test "GET /api/v1/forum/topics/:id answers 409 for an ambiguous prefix", %{

    conn: conn,

    forum: forum

  } do

    topic_with_id(forum, "88888888-4001-4001-8001-000000000001")

    topic_with_id(forum, "88888888-4002-4002-8002-000000000002")

    conn = get(conn, ~p"/api/v1/forum/topics/88888888")

    assert %{"error" => "ambiguous_id"} = json_response(conn, 409)

  end

  test "GET /api/v1/forum/topics/:id answers 404 for a prefix that matches nothing", %{conn: conn} do

    conn = get(conn, ~p"/api/v1/forum/topics/deadbeef")

    assert %{"error" => "not_found"} = json_response(conn, 404)

  end

  test "POST /api/v1/forum/topics creates a topic attributed to the token account", %{conn: conn} do

    conn =

      conn