phoenix-api-channels
Phoenix controllers, JSON APIs, Channels, and Presence on the BEAM
- License 许可
- MIT
- 最近更新
- 2026-05-22
- Stars
- ★ 0
- Forks
- 0
01 前言 Front Matter
- name
- phoenix-api-channels
- author
- Claude MPM Team
- license
- MIT
- version
- 1.0.0
- category
- toolchain
- description
- Phoenix controllers, JSON APIs, Channels, and Presence on the BEAM
- progressive_disclosure
- { "entry_point": { "summary": "Phoenix REST/JSON + Channels/Presence on the BEAM with contexts, plugs, auth, and PubSub.", "quick_start": [ "mix phx.new my_api --no-html --no-live && cd my_api", "mix deps.get && mix ecto.create", "Define contexts + schemas; add routes/controllers; wire `socket` + Channel modules", "Start server: mix phx.server (REST + WebSocket on http://localhost:4000)" ], "when_to_use": [ "Building JSON APIs with Phoenix controllers and versioned routes", "Adding WebSocket/Channels for chat, notifications, or collaborative features", "Needing Presence tracking, fan-out broadcasts, and PubSub-backed updates", "Integrating Ecto contexts for persistence and domain boundaries" ] }, "token_estimate": { "full": 5200, "entry": 170 } }
03 SKILL.md 正文
Phoenix APIs, Channels, and Presence (Elixir/BEAM)
Phoenix excels at REST/JSON APIs and WebSocket Channels with minimal boilerplate, leveraging the BEAM for fault tolerance, lightweight processes, and supervised PubSub/Presence.
Core pillars
- Controllers for JSON APIs with plugs, pipelines, and versioning.
- Contexts own data (Ecto schemas + queries) and expose a narrow API to controllers/channels.
- Channels + PubSub for fan-out real-time updates; Presence for tracking users/devices.
- Auth via plugs (session/cookie for browser, token/Bearer for APIs), with signed params.
Project Setup
mix phx.new my_api --no-html --no-live
cd my_api
mix deps.get
mix ecto.create
mix phx.server
Key files:
lib/my_api_web/endpoint.ex— plugs, sockets, instrumentationlib/my_api_web/router.ex— pipelines, scopes, versioning, socketslib/my_api_web/controllers/*— REST/JSON controllerslib/my_api/*— contexts + Ecto schemas (ownership of data logic)lib/my_api_web/channels/*— Channel modules
Routing and Pipelines
Separate browser vs API pipelines; version APIs with scopes.
defmodule MyApiWeb.Router do
use MyApiWeb, :router
pipeline :api do
plug :accepts, ["json"]
plug :fetch_session
plug :protect_from_forgery
plug MyApiWeb.Plugs.RequireAuth
end
scope "/api", MyApiWeb do
pipe_through :api
scope "/v1", V1, as: :v1 do
resources "/users", UserController, except: [:new, :edit]
post "/sessions", SessionController, :create
end
end
socket "/socket", MyApiWeb.UserSocket,
websocket: [connect_info: [:peer_data, :x_headers]],
longpoll: false
end
Tips
- Keep pipelines short; push auth/guards into plugs.
- Expose
socket "/socket"for Channels; restrict transports as needed.
Controllers and Plugs
Controllers stay thin; contexts own the logic.
defmodule MyApiWeb.V1.UserController do
use MyApiWeb, :controller
alias MyApi.Accounts
action_fallback MyApiWeb.FallbackController
def index(conn, _params) do
users = Accounts.list_users()
render(conn, :index, users: users)
end
def create(conn, params) do
with {:ok, user} <- Accounts.register_user(params) do
conn
|> put_status(:created)
|> put_resp_header("location", ~p\"/api/v1/users/#{user.id}\")
|> render(:show, user: user)
end
end
end
FallbackController centralizes error translation ({:error, :not_found} → 404 JSON).
Plugs
RequireAuthverifies bearer/session tokens, setscurrent_user.- Use
plug :scrub_params-style transforms in pipelines, not controllers. - Avoid heavy work in plugs; they run per-request.
Contexts and Data (Ecto)
Contexts expose only what controllers/channels need.
defmodule MyApi.Accounts do
import Ecto.Query, warn: false
alias MyApi.{Repo, Accounts.User}
def list_users, do: Repo.all(User)
def get_user!(id), do: Repo.get!(User, id)
def register_user(attrs) do
%User{}
|> User.registration_changeset(attrs)
|> Repo.insert()
end
end
Guidelines
- Keep schema modules free of controller knowledge.
- Validate at the changeset; use
Ecto.Multifor multi-step operations. - Prefer pagination helpers (
Scrivener,Flop) for large lists.
Channels, PubSub, and Presence
Channel module example:
defmodule MyApiWeb.RoomChannel do
use Phoenix.Channel
alias Phoenix.Presence
def join("room:" <> room_id, _payload, socket) do
send(self(), :after_join)
{:ok, assign(socket, :room_id, room_id)}
end
def handle_info(:after_join, socket) do
Presence.track(socket, socket.assigns.user_id, %{online_at: System.system_time(:second)})
push(socket, "presence_state", Presence.list(socket))
{:noreply, socket}
end
def handle_in("message:new", %{"body" => body}, socket) do
broadcast!(socket, "message:new", %{user_id: socket.assigns.user_id, body: body})
{:noreply, socket}
end
end
PubSub from contexts
def create_order(attrs) do
with {:ok, order} <- %Order{} |> Order.changeset(attrs) |> Repo.insert() do
Phoenix.PubSub.broadcast(MyApi.PubSub, "orders", {:order_created, order})
{:ok, order}
end
end
Best practices
- Authorize in
UserSocket.connect/3before joining topics. - Limit payload sizes; validate incoming events.
- Use topic partitioning for tenancy (
"tenant:" <> tenant_id <> ":room:" <> room_id).
Authentication Patterns
- API tokens: Accept
authorization: Bearer <token>; verify in plug, assigncurrent_user. - Signed params:
Phoenix.Token.sign/verifyfor short-lived join params. - Rate limiting: Use plugs + ETS/Cachex or reverse proxy (NGINX/Cloudflare).
- CORS: Configure in
Endpointwithcors_plug.
Testing
Use generated helpers:
defmodule MyApiWeb.UserControllerTest do
use MyApiWeb.ConnCase, async: true
test "lists users", %{conn: conn} do
conn = get(conn, ~p\"/api/v1/users\")
assert json_response(conn, 200)["data"] == []
end
end
Channel tests:
defmodule MyApiWeb.RoomChannelTest do
use MyApiWeb.ChannelCase, async: true
test "broadcasts messages" do
{:ok, _, socket} = connect(MyApiWeb.UserSocket, %{"token" => "abc"})
{:ok, _, socket} = subscribe_and_join(socket, "room:123", %{})
ref = push(socket, "message:new", %{"body" => "hi"})
assert_reply ref, :ok
assert_broadcast "message:new", %{body: "hi"}
end
end
DataCase: isolates DB per test; use fixtures/factories for setup.
Telemetry, Observability, and Ops
:telemetryevents from endpoint, controller, channel, and Ecto queries; export viaOpentelemetryPhoenixandOpentelemetryEcto.- Use
Plug.Telemetryfor request metrics; add logging metadata (request_id, user_id). - Releases:
MIX_ENV=prod mix release; configure runtime inconfig/runtime.exs. - Clustering:
libcluster+ distributed PubSub for multi-node Presence. - Assetless APIs: disable unused watchers (esbuild/tailwind) for API-only apps.
Common Pitfalls
- Controllers doing queries directly instead of delegating to contexts.
- Not authorizing in
UserSocket.connect/3, leading to topic exposure. - Missing
action_fallback→ inconsistent error shapes. - Forgetting to limit event payloads; large messages can overwhelm channels.
- Leaving longpoll enabled when unused; disable to reduce surface area.
Phoenix API + Channels shine when contexts own data, controllers stay thin, and Channels use PubSub/Presence with strict authorization and telemetry. The BEAM handles concurrency and fault tolerance; focus on clear boundaries and real-time experiences.
04 同仓库更多 Skills
simpy
Process-based discrete-event simulation framework in Python. Use this skill when building simulations of systems with processes, queues, resources, and time-based events such as manufacturing systems, service operations, network traffic, logistics, or any system where entities interact with shared resources over time.
shopify-expert
Builds and debugs Shopify themes (.liquid files, theme.json, sections), develops custom Shopify apps (shopify.app.toml, OAuth, webhooks), and implements Storefront API integrations for headless storefronts. Use when building or customizing Shopify themes, creating Hydrogen or custom React storefronts, developing Shopify apps, implementing checkout UI extensions or Shopify Functions, optimizing performance, or integrating third-party services. Invoke for Liquid templating, Storefront API, app development, checkout customization, Shopify Plus features, App Bridge, Polaris, or Shopify CLI workflows.
shap
Model interpretability and explainability using SHAP (SHapley Additive exPlanations). Use this skill when explaining machine learning model predictions, computing feature importance, generating SHAP plots (waterfall, beeswarm, bar, scatter, force, heatmap), debugging models, analyzing model bias or fairness, comparing models, or implementing explainable AI. Works with tree-based models (XGBoost, LightGBM, Random Forest), deep learning (TensorFlow, PyTorch), linear models, and any black-box model.
shadcn-ui
Deep expertise on shadcn/ui component library including installation, customization, theming, and accessibility patterns. Use when building UI with shadcn/ui components, integrating Radix UI primitives, configuring Tailwind CSS v4 themes, or implementing dark mode. Covers Next.js App Router, Pages Router, and Vite setups.
seoul-subway-arrival
Look up Seoul real-time subway arrival information with the official Seoul Open Data API. Use when the user asks when a train arrives, which trains are approaching a station, or how crowded Seoul subway timing looks right now.
seo-optimization
Comprehensive 7-phase SEO optimization workflow covering technical SEO auditing, keyword research strategy, on-page optimization, content SEO and E-E-A-T, structured data implementation, link building, and AI search optimization. Use when auditing search engine visibility, diagnosing ranking issues, implementing schema markup, conducting keyword research, optimizing content for E-E-A-T signals, or adapting for AI-driven search (AI Overviews, SGE).