# In a controller or LiveView — generate a token for the current user
defmodule MyAppWeb.UserAuth do
  def generate_socket_token(conn) do
    Phoenix.Token.sign(conn, "user socket", conn.assigns.current_user.id)
  end
end
 
# In your layout or root template
<script>
  window.userToken = "<%= Phoenix.Token.sign(@conn, "user socket", @current_user.id) %>"
</script>

defmodule MyAppWeb.UserSocket do
  use Phoenix.Socket
 
  channel "room:*", MyAppWeb.RoomChannel
  channel "notifications:*", MyAppWeb.NotificationChannel
 
  @impl true
  def connect(%{"token" => token}, socket, _connect_info) do
    # Tokens expire after 2 weeks by default — configure max_age
    case Phoenix.Token.verify(socket, "user socket", token, max_age: 1_209_600) do
      {:ok, user_id} ->
        {:ok, assign(socket, :user_id, user_id)}
 
      {:error, _reason} ->
        :error
    end
  end
 
  def connect(_params, _socket, _connect_info), do: :error
 
  @impl true
  def id(socket), do: "users_socket:#{socket.assigns.user_id}"
end

# No authentication — anyone can connect
def connect(_params, socket, _connect_info) do
  {:ok, socket}
end

defmodule MyAppWeb.RoomChannel do
  use MyAppWeb, :channel
 
  @impl true
  def join("room:" <> room_id, _payload, socket) do
    user_id = socket.assigns.user_id
 
    if Rooms.member?(room_id, user_id) do
      {:ok, assign(socket, :room_id, room_id)}
    else
      {:error, %{reason: "unauthorized"}}
    end
  end
end

# No authorization — any authenticated user can join any room
def join("room:" <> room_id, _payload, socket) do
  {:ok, assign(socket, :room_id, room_id)}
end

@impl true
def handle_in("new_msg", %{"body" => body}, socket) do
  user_id = socket.assigns.user_id
  room_id = socket.assigns.room_id
 
  case Chat.create_message(room_id, user_id, body) do
    {:ok, message} ->
      broadcast!(socket, "new_msg", %{
        id: message.id,
        body: message.body,
        user_id: message.user_id,
        inserted_at: message.inserted_at
      })
      {:reply, :ok, socket}
 
    {:error, changeset} ->
      {:reply, {:error, %{errors: format_errors(changeset)}}, socket}
  end
end

# No reply — client doesn't know if message was received
def handle_in("new_msg", %{"body" => body}, socket) do
  broadcast!(socket, "new_msg", %{body: body})
  {:noreply, socket}
end

# Push to this specific client only
push(socket, "typing", %{user_id: other_user_id})
 
# Broadcast to all clients on the topic (including sender)
broadcast!(socket, "new_msg", payload)
 
# Broadcast to all clients except the sender
broadcast_from!(socket, "user_joined", %{user_id: user_id})

@impl true
def handle_info({:new_notification, notification}, socket) do
  push(socket, "notification", %{
    title: notification.title,
    body: notification.body
  })
  {:noreply, socket}
end

# Resource-specific — one room
"room:42"
 
# User-scoped — all notifications for a user
"notifications:user_123"
 
# Collection-wide — all public updates
"updates:all"
 
# Subtopic — specific channel within a room
"room:42:typing"

def join("room:" <> room_id, _payload, socket) do
  # room_id is a string — parse if needed
  room_id = String.to_integer(room_id)
  # ...
end

# lib/my_app_web/channels/presence.ex
defmodule MyAppWeb.Presence do
  use Phoenix.Presence,
    otp_app: :my_app,
    pubsub_server: MyApp.PubSub
end

defmodule MyAppWeb.RoomChannel do
  use MyAppWeb, :channel
  alias MyAppWeb.Presence
 
  @impl true
  def join("room:" <> room_id, _payload, socket) do
    send(self(), :after_join)
    {:ok, assign(socket, :room_id, room_id)}
  end
 
  @impl true
  def handle_info(:after_join, socket) do
    # Track this user's presence
    {:ok, _} = Presence.track(socket, socket.assigns.user_id, %{
      online_at: inspect(System.system_time(:second)),
      typing: false
    })
 
    # Send current presence state to the joining client
    push(socket, "presence_state", Presence.list(socket))
 
    {:noreply, socket}
  end
end

@impl true
def handle_in("typing", %{"typing" => typing}, socket) do
  Presence.update(socket, socket.assigns.user_id, fn meta ->
    Map.put(meta, :typing, typing)
  end)
  {:reply, :ok, socket}
end

defmodule MyAppWeb.RoomChannelTest do
  use MyAppWeb.ChannelCase
 
  setup do
    user = user_fixture()
    room = room_fixture(members: [user])
    token = Phoenix.Token.sign(MyAppWeb.Endpoint, "user socket", user.id)
    {:ok, socket} = connect(MyAppWeb.UserSocket, %{"token" => token})
    {:ok, _, socket} = subscribe_and_join(socket, "room:#{room.id}", %{})
 
    %{socket: socket, user: user, room: room}
  end
 
  test "new_msg broadcasts to room", %{socket: socket} do
    ref = push(socket, "new_msg", %{"body" => "hello"})
 
    assert_reply ref, :ok
    assert_broadcast "new_msg", %{body: "hello"}
  end
 
  test "new_msg with invalid data returns error", %{socket: socket} do
    ref = push(socket, "new_msg", %{"body" => ""})
 
    assert_reply ref, :error, %{errors: _}
  end
 
  test "unauthorized user cannot join room" do
    other_user = user_fixture()
    token = Phoenix.Token.sign(MyAppWeb.Endpoint, "user socket", other_user.id)
    {:ok, socket} = connect(MyAppWeb.UserSocket, %{"token" => token})
 
    assert {:error, %{reason: "unauthorized"}} =
             subscribe_and_join(socket, "room:#{room.id}", %{})
  end
 
  test "presence is tracked on join", %{socket: socket, user: user} do
    assert %{^(to_string(user.id)) => %{metas: [%{online_at: _}]}} =
             MyAppWeb.Presence.list(socket)
  end
end