plug_rails_cookie_session_store alternatives and similar packages
Based on the "Framework Components" category.
Alternatively, view plug_rails_cookie_session_store 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. -
surface
A server-side rendering component library for Phoenix. -
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). -
corsica
Elixir library for dealing with CORS requests. -
scrivener_html
Helpers built to work with Scrivener's page struct to easily build HTML output for various CSS frameworks. -
phoenix_slime
Slim template support for Phoenix. -
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_token_auth
Token authentication solution for Phoenix. Useful for APIs or single page apps. -
passport
Passport provides authentication for Phoenix applications. -
phoenix_pubsub_redis
The Redis PubSub adapter for the Phoenix framework. -
rummage_phoenix
A support framework for searching, sorting and paginating models in Phoenix, with support HTML support. -
phoenix_haml
Phoenix Template Engine for Haml. -
recaptcha
A simple reCaptcha 2 library for Elixir applications. -
plug_graphql
Phoenix Plug integration for GraphQL Elixir. -
sentinel
An authentication framework for Phoenix extending guardian with routing and other basic functionality. -
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. -
ashes
A code generation tool for the Phoenix web framework. -
plug_auth
Collection of authentication-related plugs. -
filterable
Simple query params filtering for Phoenix framework inspired by Rails has_scope. -
phoenix_pubsub_rabbitmq
RabbitMQ adapter for Phoenix's PubSub layer. -
better_params
Elixir Plug for cleaner request params in web apps. -
plug_checkup
Plug for adding simple health checks to your app. -
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. -
plug_rest
REST behaviour and Plug router for hypermedia web applications. -
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.
Get performance insights in less than 4 minutes
Do you think we are missing an alternative of plug_rails_cookie_session_store or a related project?
README
PlugRailsCookieSessionStore
Rails compatible Plug session store.
This allows you to share session information between Rails and a Plug-based framework like Phoenix.
Installation
Add PlugRailsCookieSessionStore as a dependency to your mix.exs
file:
def deps do
[{:plug_rails_cookie_session_store, "~> 1.0"}]
end
How to use with Phoenix
Copy/share the encryption information from Rails to Phoenix.
There are 4 things to copy:
- secret_key_base
- signing_salt
- encryption_salt
- session_key
Since Rails 5.2, secret_key_base
in test and development is derived as a MD5 hash of the application's name. To fetch key value you can run:
Rails.application.secret_key_base
https://www.rubydoc.info/github/rails/rails/Rails%2FApplication:secret_key_base
The secret_key_base
should be copied to Phoenix's config.exs
file. There should already be a key named like that and you should override it.
The other three values can be found somewhere in the initializers directory of your Rails project. Some people don't set the signing_salt
and encryption_salt
. If you don't find them, set them like so:
Rails.application.config.session_store :cookie_store, key: '_SOMETHING_HERE_session'
Rails.application.config.action_dispatch.encrypted_cookie_salt = 'encryption salt'
Rails.application.config.action_dispatch.encrypted_signed_cookie_salt = 'signing salt'
Configure the Cookie Store in Phoenix.
Edit the endpoint.ex
file and add the following:
# ...
plug Plug.Session,
store: PlugRailsCookieSessionStore,
key: "_SOMETHING_HERE_session",
domain: '.myapp.com',
secure: true,
signing_with_salt: true,
signing_salt: "signing salt",
encrypt: true,
encryption_salt: "encryption salt",
key_iterations: 1000,
key_length: 64,
key_digest: :sha,
serializer: Poison # see serializer details below
end
Set up a serializer
Plug & Rails must use the same strategy for serializing cookie data.
- JSON: Since 4.1, Rails defaults to serializing cookie data with JSON. Support this strategy by getting a JSON serializer and passing it to
Plug.Session
. For example, addPoison
to your dependencies, then:
plug Plug.Session,
store: PlugRailsCookieSessionStore,
# ... see encryption config above
serializer: Poison
end
You can confirm that your app uses JSON by searching for
Rails.application.config.action_dispatch.cookies_serializer = :json
in an initializer.
- Marshal: Previous to 4.1, Rails defaulted to Ruby's
Marshal
library for serializing cookie data. You can deserialize this by addingExMarshal
to your project and defining a serializer module:
defmodule RailsMarshalSessionSerializer do
@moduledoc """
Share a session with a Rails app using Ruby's Marshal format.
"""
def encode(value) do
{:ok, ExMarshal.encode(value)}
end
def decode(value) do
{:ok, ExMarshal.decode(value)}
end
end
Then, pass that module as a serializer to Plug.Session
:
plug Plug.Session,
store: PlugRailsCookieSessionStore,
# ... see encryption config above
serializer: RailsMarshalSessionSerializer
end
- Rails 3.2: Rails 3.2 uses unsalted signing, to make Phoenix share session with Rails 3.2 project you need to set up
ExMarshal
mentioned above, with following configuration in yourPlug.Session
:
plug Plug.Session,
store: PlugRailsCookieSessionStore,
# ... see encryption/ExMarshal config above
signing_with_salt: false,
end
That's it!
To test it, set a session value in your Rails application:
session[:foo] = 'bar'
And print it on Phoenix in whatever Controller you want:
Logger.debug get_session(conn, "foo")