Raxx alternatives and similar packages
Based on the "Framework Components" category.
Alternatively, view Raxx alternatives based on common mentions on social networks and blogs.
-
plug
A specification and conveniences for composable modules in between web applications. -
ex_admin
ExAdmin is an auto administration package for Elixir and the Phoenix Framework. -
commanded
Command handling middleware for Command Query Responsibility Segregation (CQRS) applications. -
torch
Torch is a rapid admin generator for Phoenix apps. It uses generators rather than DSLs to ensure that the code remains maintainable. -
phoenix_html
Phoenix.HTML functions for working with HTML strings and templates. -
react_phoenix
Make rendering React.js components in Phoenix views easy -
cors_plug
An Elixir plug that adds CORS headers to requests and responds to preflight requests (OPTIONS). -
scrivener_html
Helpers built to work with Scrivener's page struct to easily build HTML output for various CSS frameworks. -
phoenix_live_reload
Provides live-reload functionality for Phoenix. -
params
Use Ecto to enforce/validate parameters structure, akin to Rails' strong parameters. -
dayron
A repository similar to Ecto.Repo that works with REST API requests instead of a database. -
rummage_ecto
A configurable framework to search, sort and paginate Ecto Queries. -
phoenix_pubsub_redis
The Redis PubSub adapter for the Phoenix framework. -
phoenix_token_auth
Token authentication solution for Phoenix. Useful for APIs or single page apps. -
rummage_phoenix
A support framework for searching, sorting and paginating models in Phoenix, with support HTML support. -
sentinel
An authentication framework for Phoenix extending guardian with routing and other basic functionality. -
plug_rails_cookie_session_store
Rails compatible Plug session store. -
access pass
Authentication framework that can be used with or outside of phoenix. Similar to Addict but geared towards API usage.(Docs). -
multiverse
Plug that allows to add version compatibility layers via API Request/Response Gateways. -
filterable
Simple query params filtering for Phoenix framework inspired by Rails has_scope. -
phoenix_pubsub_rabbitmq
RabbitMQ adapter for Phoenix's PubSub layer. -
plug_statsd
A plug for automatically sending timing and count metrics to statsd. -
trailing_format_plug
An Elixir plug to support legacy APIs that use a rails-like trailing format. -
scrivener_headers
Helpers for paginating API responses with Scrivener and HTTP headers. -
phoenix_html_simplified_helpers
Some helpers for phoenix html (truncate, time_ago_in_words, number_with_delimiter). -
Votex
Hex Package : Implements vote / like / follow functionality for Ecto models in Phoenix -
phoenix_pubsub_postgres
Postgresql PubSub adapter for Phoenix apps. -
phoenix_pubsub_vernemq
The VerneMQ MQTT pubsub adapter for the Phoenix framework.
Scout APM - Leading-edge performance monitoring starting at $39/month
Do you think we are missing an alternative of Raxx or a related project?
Popular Comparisons
README
Raxx
Interface for HTTP webservers, frameworks and clients.
See Raxx.Kit for a project generator that helps you set up a web project based on Raxx/Ace.
Simple server
1. Defining a server
defmodule MyServer do
use Raxx.SimpleServer
@impl Raxx.SimpleServer
def handle_request(%{method: :GET, path: []}, _state) do
response(:ok)
|> set_header("content-type", "text/plain")
|> set_body("Hello, World!")
end
def handle_request(%{method: :GET, path: _}, _state) do
response(:not_found)
|> set_header("content-type", "text/plain")
|> set_body("Oops! Nothing here.")
end
end
- A request's path is split into segments.
A request to
GET /
has path[]
.
2. Running a server
To start a Raxx server a compatible HTTP server is needed. This example uses Ace that can serve both HTTP/1 and HTTP/2.
raxx_server = {MyServer, nil}
http_options = [port: 8080, cleartext: true]
{:ok, pid} = Ace.HTTP.Service.start_link(raxx_server, http_options)
- The second element in the Raxx server tuple is passed as the second argument to the
handle_request/2
callback. In this example it is unused and so set to nil.
Start your project and visit http://localhost:8080.
HTTP streaming
An HTTP exchange involves a client sending data to a server receiving a response.
A simple view is to model this as a single message sent in each direction.
Working with this model corresponds to Raxx.SimpleServer
callbacks.
request -->
Client ============================================ Server
<-- response
When the simple model is insufficient Raxx exposes a lower model.
This consists of a series of messages in each direction.
Working with this model corresponds to Raxx.Server
callbacks.
tail | data(1+) | head(request) -->
Client ============================================ Server
<-- head(response) | data(1+) | tail
- The body of a request or a response, is the combination of all data parts sent.
Stateful server
The LongPoll
server is stateful.
After receiving a complete request this server has to wait for extra input before sending a response to the client.
defmodule LongPoll do
use Raxx.Server
@impl Raxx.Server
def handle_head(%{method: :GET, path: ["slow"]}, state) do
Process.send_after(self(), :reply, 30_000)
{[], state}
end
@impl Raxx.Server
def handle_info(:reply, _state) do
response(:ok)
|> set_header("content-type", "text/plain")
|> set_body("Hello, Thanks for waiting.")
end
end
- A long lived server needs to return two things; the message parts to send, in this case nothing
[]
; and the new state of the server, in this case no changestate
. - The
initial_state
is configured when the server is started.
Server streaming
The SubscribeToMessages
server streams its response.
The server will send the head of the response upon receiving the request.
Data is sent to the client, as part of the body, when it becomes available.
The response is completed when the chatroom sends a :closed
message.
defmodule SubscribeToMessages do
use Raxx.Server
@impl Raxx.Server
def handle_head(%{method: :GET, path: ["messages"]}, state) do
{:ok, _} = ChatRoom.join()
outbound = response(:ok)
|> set_header("content-type", "text/plain")
|> set_body(true)
{[outbound], state}
end
@impl Raxx.Server
def handle_info({ChatRoom, :closed}, state) do
outbound = tail()
{[outbound], state}
end
def handle_info({ChatRoom, data}, state) do
outbound = data(data)
{[outbound], state}
end
end
- Using
set_body(true)
marks that the response has a body that it is not yet known. - A stream must have a tail to complete, metadata added here will be sent as trailers.
Client streaming
The Upload
server writes data to a file as it is received.
Only once the complete request has been received is a response sent.
defmodule Upload do
use Raxx.Server
@impl Raxx.Server
def handle_head(%{method: :PUT, path: ["upload"] body: true}, _state) do
{:ok, io_device} = File.open("my/path")
{[], {:file, device}}
end
@impl Raxx.Server
def handle_data(data, state = {:file, device}) do
IO.write(device, data)
{[], state}
end
@impl Raxx.Server
def handle_tail(_trailers, state) do
response(:see_other)
|> set_header("location", "/")
end
end
- A body may arrive split by packets, chunks or frames.
handle_data
will be invoked as each part arrives. An application should never assume how a body will be broken into data parts.
Request/Response flow
It is worth noting what guarantees are given on the request parts passed to the
Server's handle_*
functions. It depends on the Server type,
Raxx.Server
vs Raxx.SimpleServer
:
<!-- NOTE: diagram svg files contain the source diagram and can be edited using draw.io --> [request flow](assets/request_flow.svg)
So, for example, after a %Raxx.Request{body: false}
is passed to a Server's c:Raxx.Server.handle_head/2
callback, no further request parts will be passed to to the server (c:Raxx.Server.handle_info/2
messages might be, though).
Similarly, these are the valid sequences of the response parts returned from the Servers:
<!-- NOTE: diagram svg files contain the source diagram and can be edited using draw.io --> [response flow](assets/response_flow.svg)
Any Raxx.Middleware
s should follow the same logic.
Router
The Raxx.Router
can be used to match requests to specific server modules.
defmodule MyApp do
use Raxx.Server
use Raxx.Router, [
{%{method: :GET, path: []}, HomePage},
{%{method: :GET, path: ["slow"]}, LongPoll},
{%{method: :GET, path: ["messages"]}, SubscribeToMessages},
{%{method: :PUT, path: ["upload"]}, Upload},
{_, NotFoundPage}
]
end
*Note that all licence references and agreements mentioned in the Raxx README section above
are relevant to that project's source code only.