
Access Lightning Rails, The best Ruby on Rails Boilerplate for solopreneurs.		/files/KJYbXJksKJpLQ8uCjepF
Getting Started	Clone the repo and get your server started	/files/EQLr6OiEYNhp3a4gTKtG	/pages/Zvukm7MAGL6ooitMTmpY
Themes and styling	Make the project your own by defining a theme and landing page components	/files/9e15j3cwiVJRk42GyABp	/pages/JjjojIyKxaiBPzzLwvtg

Access Lightning Rails, The best Ruby on Rails Boilerplate for solopreneurs.

Getting Started

Clone the repo and get your server started

Themes and styling

Make the project your own by defining a theme and landing page components

# views/home.html.erb <%= render "components/hero" %> <%= render "components/featured_on" %> <%= render "components/text_image" %> <%= render "components/feature_tabs" %> <%= render "components/price_cards" %> <%= render "components/faq" %> <%= render "components/cta_horizontal" %>

# Modify content to adapt to each page, for example with pricing.html.erb <% content_for :meta_title, "No trick pricing on #{DEFAULT_META["meta_product_name"]}" %> <% content_for :meta_description, "Get more for less, access our pro membership to build rails apps in seconds" %> <% content_for :meta_image, "cover.png" %> <h1>Pricing</h1> [...]


Postmark Setup	/pages/cEHgDv7NGBquDGHeLyQ4	/files/SYTWAl215xmLCTOrHtA2
Resend Setup	/pages/FhvQWkQW8ICo36uBGRWC	/files/Cko6Y1bnzxV8VxhZgnCX

Postmark Setup

/pages/cEHgDv7NGBquDGHeLyQ4

/files/SYTWAl215xmLCTOrHtA2

Resend Setup

/pages/FhvQWkQW8ICo36uBGRWC

/files/Cko6Y1bnzxV8VxhZgnCX

Welcome to Our App, <%= @user.name %>!

We’re excited to have you on board.

<%= f.label :first_name %> <%= f.text_field :first_name, autofocus: true %>

<%= f.label :last_name %> <%= f.text_field :last_name %>

Magic link just needs an email, no password 🥳

Hello, <%= @user.email %>!

Someone requested a sign-in link for your account. Click the link below to sign in:

<%= email_field_tag :email, nil, placeholder: "mclovin@gmail.com" %>

<%= submit_tag "Log in", class: "btn btn-primary" %>

Credentials Edit file

" %} Tutorial for adding github authentiaciton to Lightning Rails {% endembed %} ## Install Github authentication Gem The first step will be to install the [omniauth Github gem.](https://github.com/omniauth/omniauth) In our Gemfile, let's add ```ruby gem 'omniauth' gem 'omniauth-rails_csrf_protection' gem 'omniauth-github' ``` As usual, we will bundle ``` bundle install ``` As we wish to have our users sign up with Github, we must let devise know. Let's go into the initializers/devise.rb file and add this line: ```ruby # config/initializers/devise.rb # ==> OmniAuth config.omniauth :github, ENV["GITHUB_ID"], ENV["GITHUB_SECRET"], scope: 'user,public_repo' ``` ## Create a Github OAuth App Now that we have done some config, we can see that we are missing the API keys that will connect our app to GitHub. Unlike Google OAuth, Github is very easy to create. * [ ] **Create** a new app [here.](https://github.com/settings/applications/new) * [ ] Add your authentication code if required. * [ ] **Give your application the name** "My Super Cool App Development" * [ ] **Give a Homepage URL:** (we will create a second OAuth app for production and real domain) * [ ] Add an application description for your users * [ ] Add exactly this URL as app callback: (we will change it for the production environment) * [ ] Save and add your logo if you have one You will see that you have a CLIENT ID but still need to generate a new secret key, so let's do it by clicking "Generate a new client secret". ## Add keys to .env Copy the Secret key and add it to your .env file along with the client ID: ``` # .env # modify with your keys GITHUB_ID=Ov23********* GITHUB_SECRET=3cc73c*********************** ``` ## Routes Now that we have a good config, we'll need to activate new routes, and replace the existing `devise_for :user` by this line: ```ruby # routes.rb devise_for :users, controllers: { omniauth_callbacks: 'users/omniauth_callbacks' } ``` ## Controller Let's create that new controller we added to the routes, in the terminal run: ``` mkdir app/controllers/users ``` And ``` touch app/controllers/users/omniauth_callbacks_controller.rb ``` Now in our brand new controller file, we will add the GitHub OmniAuth logic: ```ruby # app/controllers/users/omniauth_callbacks_controller.rb class Users::OmniauthCallbacksController < Devise::OmniauthCallbacksController def github @user = User.from_omniauth(request.env['omniauth.auth']) if @user.persisted? sign_in_and_redirect @user, event: :authentication flash[:notice] = I18n.t 'devise.omniauth_callbacks.success', kind: 'Github' else session['devise.github_data'] = request.env['omniauth.auth'].except('extra') redirect_to new_user_registration_url, alert: @user.errors.full_messages.join("\n") end end end ``` ## Model After adding the proper routes and controller action we will need to activate the Omniauth option from devise. In `user.rb` uncomment and add the following symbols to the devise options: ```ruby # models/user.rb class User < ApplicationRecord # Include default devise modules. Others available are: # :confirmable, :lockable, :timeoutable, :trackable devise :database_authenticatable, :registerable, :recoverable, :rememberable, :validatable, :omniauthable, omniauth_providers: [:github] # <- The new options # [...] end ``` We will also add the Omniauthable custom method: ```ruby # models/user.rb class User < ApplicationRecord # has_one_attached :avatar <- Uncomment If you want to attach a picture from github # [...] def self.from_omniauth(access_token) data = access_token.info user = User.where(email: data['email']).first if user user.update( # Optional: You can create a migration for users to add GitHub username and name to the user instance. # github_username: data['nickname'], # name: data['name'], email: data['email'] ) else user = User.create( # Optional: You can create a migration for users to add GitHub username and name to the user instance. # github_username: data['nickname'], # name: data['name'], email: data['email'], password: Devise.friendly_token[0,20] ) end # Optional: Uncomment for adding avatar image from github, make sure you have a cloudinary API_KEY in your .env # user.avatar.purge if user.avatar.attached? # user.avatar.attach(io: URI.open(data['image']), filename: 'avatar.jpg', content_type: 'image/jpg') user end end ``` ## Views Let's add the GitHub signup to the sessions/new file. I like to add it to the login instead of the signup as to not lose the before\_action :authenticate\_user! auto-redirect function. As our code either updates or creates. You can now ignore the signup page and unlink it from all the buttons on your page. ```erb #app/views/sessions/new.html.erb # [...] # Add this code where you want the GitHub sign in button <%- if devise_mapping.omniauthable? %> <%- resource_class.omniauth_providers.each do |provider| %> <%= button_to omniauth_authorize_path(resource_name, provider), data: { turbo: false }, class: "btn btn-primary mt-12" do %> Sign in with Github
<% end %> Your Github Username to receive an automatic invite to LightningRails repo. <% end %> <% end %> # [...] ``` ## In Production To have this code work on production as well as on development, you will need to create a second Github app and follow these steps again: * [ ] **Create** a new app [here.](https://github.com/settings/applications/new) * [ ] Add your authentication code if required. * [ ] **Give your application the name** "My Super Cool App Production" * [ ] **Give a Homepage URL:** (we will create a second OAuth app for production and real domain) * [ ] Add an application description for your users * [ ] Add exactly this URL as app callback: (change this domain to your final live domain) * [ ] Save and add your logo if you have one Now you should have two GitHub apps. One for development and one for production. The only step left will be to add the production ID and key to Heroku from your terminal:\ *(replace the API key by your actual production API key and ID)*

heroku config:set GITHUB_SECRET=YOUR_API_KEY

And ``` heroku config:set GITHUB_ID=YOUR_GITHUB_ID ``` Et voila! You have a brand-new GitHub authentication setup. Your techy users will thank you! 🙏 *** {% hint style="info" %} Common Errors 🐞: * Omniauthable is undefined: Did you restart your server after installing the Omniauthable Gem? If not do it an it should get fixed. * Must supply API\_KEY: Are you adding avatars without a Cloudinary key in your .env file? That's probably the cause, head to Cloudinary, and add your API key in the .env file. {% endhint %} # Lucide icons Easily add SVG icons to your project with only one line of code. {% embed url="" %} Short tutorial on how to sue the Lucide Library {% endembed %} {% hint style="info" %} **Lucide.dev License disclaimer** ISC License Copyright (c) for portions of Lucide are held by Cole Bemis 2013-2022 as part of Feather (MIT). All other copyright (c) for Lucide are held by Lucide Contributors 2022. {% endhint %} ### How to add Lucide Icons to your project The first step we want to do is to [visit the Lucide Library ](https://lucide.dev/icons/)to find our ideal icon, in this case, I am looking for an arrow that goes right:

You can use the search bar to quickly find the icons

Once I find the icon I need I will copy its name to my clipboard 📋 with ctrl + c In our view we will add the following line: ```erb <%= lucide_icon("move-right") %> ``` Remember that icons behave like text, so if you want to change the size or color of the icon, simply add it as an argument: ``` <%= lucide_icon("move-right", "class" => "h-4 w-4") %> ``` Now my icon will be smaller than its default size. Now you can forget about generic FontAwesome Icons with complicated setup and generic look and feel. Happy Iconing! 🚀 # Multi-provider AI A guide on how to use the new Ruby LLM library, which allows you to connect to several LLMs instead of just using Open AI {% embed url="" %} Tutorial on how to add RubyLLM gem to your Rails app {% endembed %} ### Overview The [`ruby_llm` gem](https://github.com/crmne/ruby_llm) is a powerful, multi-provider LLM client for Ruby that makes it simple to interact with models like OpenAI, Anthropic, Gemini (Google), and Deepseek. It offers rich features like: * Real-time streaming responses * Multi-modal inputs (images, audio, PDFs) * Easy-to-define tools * Native Rails integration with `acts_as_chat` This guide walks you through how to add the **`ruby_llm`** gem in a Lightning Rails project, including configuration, usage, and upgrading of any existing service classes. *** ### Step 1: Install the `ruby_llm` Gem Add the new [gem](https://github.com/crmne/ruby_llm) to your `Gemfile`: ```ruby gem "ruby_llm" ``` Then install it: ```bash bundle install ``` Alternatively, install it directly: ```bash gem install ruby_llm ``` *** ### Step 2: Set Up Your API Keys In your `.env` file (Lightning Rails uses `dotenv-rails` by default), add: ```bash OPENAI_API_KEY=sk-... # Add others as needed # ANTHROPIC_API_KEY=... # GEMINI_API_KEY=... # DEEPSEEK_API_KEY=... ``` Then create a RubyLLM config initializer: ```bash touch config/initializers/ruby_llm.rb ``` ```ruby # config/initializers/ruby_llm.rb RubyLLM.configure do |config| config.openai_api_key = ENV['OPENAI_API_KEY'] config.anthropic_api_key = ENV['ANTHROPIC_API_KEY'] config.gemini_api_key = ENV['GEMINI_API_KEY'] config.deepseek_api_key = ENV['DEEPSEEK_API_KEY'] end ``` *** ### Step 3: Create a new ruby\_llm service Create `app/services/MultiProviderModels.rb`: ```ruby # app/services/MultiProviderModels.rb class MultiProviderModels def initialize @chat = RubyLLM.chat(model: "gpt-4o-mini") # pass the parameters here :) end def analyze_product(product) # Add a system prompt to give it context for better results. @chat.add_message role: :system, content: "You are a Product Hunt expert. Always include examples in your responses and explain them line by line." prompt = <<~PROMPT You are a product analyst expert specialized in evaluating digital products and services. You have deep knowledge of market trends, user experience, and business models. Your analysis should be structured, data-driven, and actionable. Here is a product to analyze: #{product} Please follow this process: 1. Identify the key features and unique selling points 2. Evaluate the market potential and target audience 3. Analyze pricing strategy and business model 4. Assess technical implementation and scalability 5. Provide specific recommendations for improvement Format your response in clear sections with bullet points where appropriate. Be concise but thorough in your analysis. PROMPT @chat.ask(prompt) end end ``` *** ### Step 4: Enable Streaming (Optional) If you are creating a Chatbot and don't want the users to have to reload their pages for every message, you can stream responses in real-time, by modifying the `ask` method: ```ruby @chat.ask(prompt) do |chunk| print chunk.content end ``` Or, in a controller with Turbo Streams: ```ruby @chat.ask(prompt) do |chunk| Turbo::StreamsChannel.broadcast_append_to( "ai_response", target: "response", partial: "messages/chunk", locals: { chunk: chunk } ) end ``` *** ### Bonus: Enable Native Rails Models (Optional) If you'd like to track (Save/update) chats and messages in the database, use the `acts_as_chat` setup: ```ruby # app/models/chat.rb class Chat < ApplicationRecord acts_as_chat broadcasts_to ->(chat) { "chat_#{chat.id}" } end # app/models/message.rb class Message < ApplicationRecord acts_as_message end # app/models/tool_call.rb class ToolCall < ApplicationRecord acts_as_tool_call end ``` *** ### Best Practices * Prefer `RubyLLM.chat(model: "gpt-4o-mini")` for model-specific tasks. * Use streaming when showing responses live in the UI. * Leverage multi-modal inputs (images, PDFs, audio) for advanced functionality. * Use `RubyLLM::Tool` to define reusable actions the LLM can call dynamically. * Always sanitize and validate input before using it in prompts if user-submitted. *** ### Troubleshooting **❌ Getting “Missing API key” errors?** Make sure your `.env` file includes `OPENAI_API_KEY` (or the LLM of your choice) and it is loaded via `dotenv`. **❌ Getting `undefined method acts_as_chat`?** Ensure you’ve added the proper ActiveRecord models with `acts_as_chat`, and that the `ruby_llm` gem is loaded correctly. Also, don't forget to restart your server after installing the gem. **❌ No response from `ask` method?** Wrap your call in a `puts` or log output. Also, try a basic prompt like: ```ruby RubyLLM.chat.ask("Hello, how are you?") ``` *** ### Real-World Use Cases * Product analysis and market research * Image captioning or PDF summarization * Building internal tools with custom RubyLLM::Tool classes * Streaming AI-powered responses in chat UIs or dashboards *** Read more in [the official documentation](https://rubyllm.com/) 🔥 Let me know if you’d like a Stimulus controller example or UI integration using Turbo Streams for this! # Open AI API Integrating OpenAI API and DeepSeek to your Lightning Rails Project

The anatomy of the perfect Prompt - From Open AI CEO

### Step 1: Get an OpenAI API Key 1. Sign up or log in to [OpenAI](https://platform.openai.com/). 2. Navigate to **API Keys** in the OpenAI dashboard. 3. Generate a new API key and **copy** it. You will not be able to see it again. ### Step 2: Install the [OpenAI Ruby Gem](https://github.com/alexrudall/ruby-openai) In your **Gemfile**, add: ``` gem "ruby-openai" ``` Then, run: ``` bundle install ``` ### Step 3: Configure API Key Store your API key securely in your **.env** file: ``` OPENAI_ACCESS_TOKEN=sk-...MIQ4 ``` ### Step 4: Create an OpenAI Service Create a service file **open\_ai\_api.rb** inside `app/services/`: ``` # app/services/open_ai_api.rb class OpenAiApi def initialize @client = OpenAI::Client.new(access_token: ENV["OPENAI_ACCESS_TOKEN"]) end def analyze_product(product) chatgpt_response = @client.chat(parameters: { model: "gpt-4o-mini", messages: [ { role: "system", content: "You are a product analyst expert specialized in evaluating digital products and services. You have deep knowledge of market trends, user experience, and business models. Your analysis should be structured, data-driven, and actionable." }, { role: "user", content: "Here is a product to analyze: #{product}. Please follow this process:\n\n1. Identify the key features and unique selling points\n2. Evaluate the market potential and target audience\n3. Analyze pricing strategy and business model\n4. Assess technical implementation and scalability\n5. Provide specific recommendations for improvement\n\nFormat your response in clear sections with bullet points where appropriate. Be concise but thorough in your analysis." } ] }) chatgpt_response["choices"][0]["message"]["content"] end end ```

💡 Pro Tip: Use this master prompt for better results

Copy and adapt this prompt to your needs, it was published on twitter by Greg Brockman, the current president of Open AI: ``` messages: [ { role: "system", content: "You are an expert copywriter specializing in creating engaging, persuasive, and high-converting copy for product launches. Your expertise includes analyzing industry trends, top-performing messaging strategies, and user psychology to craft compelling and attention-grabbing text." }, { role: "user", content: " ### **🎯 Goal** Your task is to generate **engaging, high-quality marketing copy** for a new product based on inspiration from past successful launches. Your response should include: - **A compelling product title** (short, catchy, and memorable). - **A tagline** (one-liner that sparks curiosity and communicates value). - **A persuasive product description** (concise, engaging, and benefit-driven). - **A first comment/post to introduce the product** (structured for maximum engagement). --- ### **📊 Context: Past Successful Launches** Below are examples of **top-performing product launches**, including their titles, taglines, and descriptions. Use these as **inspiration** to generate high-quality copy: **Top Titles:** {TOP_TITLES_PLACEHOLDER} **Top Taglines:** {TOP_TAGLINES_PLACEHOLDER} **Top Descriptions:** {TOP_DESCRIPTIONS_PLACEHOLDER} --- ### **📝 New Product Information** The new product is described as follows: **Product Name:** {PRODUCT_NAME_PLACEHOLDER} **Category:** {CATEGORY_PLACEHOLDER} **Product Summary:** {PRODUCT_SUMMARY_PLACEHOLDER} --- ### **⚠️ Warnings & Constraints** - The **title must be under 7 words** and be memorable. - The **tagline should create curiosity and communicate value clearly**. - The **description should be benefit-driven, avoiding unnecessary fluff**. - The **first comment/post should feel natural, engaging, and encourage interaction**. - Avoid **generic language**—be concise and persuasive. - Structure the response so it is **easy to read and scan quickly**. --- ### **🗣️ First Product Introduction Comment Template** Use this structure to craft the first comment/post: 🔥 **Hey everyone!** 🎯 I'm super excited to introduce **{PRODUCT_NAME_PLACEHOLDER}** today! 🚀 As {TARGET_AUDIENCE_PLACEHOLDER}, we all struggle with **{PROBLEM_PLACEHOLDER}**. It can be frustrating to {describe the pain point in a relatable way}. 🤔 I built **{PRODUCT_NAME_PLACEHOLDER}** to **{briefly describe how it solves the problem}**, making {your audience’s goal} easier and more effective. Some cool features: ✅ **{FEATURE_1_PLACEHOLDER}** - {Short description} ✅ **{FEATURE_2_PLACEHOLDER}** - {Short description} ✅ **{FEATURE_3_PLACEHOLDER}** - {Short description} Would love to hear your thoughts! **How would you use {PRODUCT_NAME_PLACEHOLDER}?** Let me know in the comments! 💡👇 --- ### **📑 Return Format** Ensure your response follows this structure for easy readability: **Title:** (Short, engaging title) **Tagline:** (One-liner tagline) **Description:** (A concise, persuasive product description) **First Comment/Post:** (Engaging, structured introduction post following the given template) --- 💡 **Final Notes:** - Be **creative but keep it natural**—avoid sounding robotic. - Use **persuasive storytelling techniques**—highlight real-world benefits. - Keep everything **clear, engaging, and optimized for conversions**. "}] ```

### Step 5: Use the Service in a Controller For example, in `products_controller.rb`: ``` class ProductsController < ApplicationController def analyze @product = params[:product] openai_service = OpenAiApi.new @analysis = openai_service.analyze_product(@product) end end ``` Then, you can create a route in **config/routes.rb**: ``` post "/analyze_product", to: "products#analyze" ``` *** ## Switching to DeepSeek API If you want to switch from OpenAI to **DeepSeek**, follow these modifications: ### Step 1: Change API Key Sign up for an API key at [DeepSeek](https://deepseek.com/) and store it in `.env`: ``` DEEPSEEK_ACCESS_TOKEN=ds-...MIQ4 ``` ### Step 2: Use the Same OpenAI Wrapper for DeepSeek DeepSeek API should compatible with the OpenAI client wrapper, meaning you only need to modify your environment variable: ``` class DeepSeekApi def initialize @client = OpenAI::Client.new(access_token: ENV["DEEPSEEK_ACCESS_TOKEN"], uri_base: "https://api.deepseek.com/v1") end def analyze_product(product) chatgpt_response = @client.chat(parameters: { model: "deepseek-chat", messages: [ { role: "system", content: "You are a product analyst expert..." }, { role: "user", content: "Here is a product to analyze: #{product}..." } ] }) chatgpt_response["choices"][0]["message"]["content"] end end ``` ### Step 3: Use DeepSeek Instead Replace **OpenAiApi** references with **DeepSeekApi** in your controllers: ``` deep_seek_service = DeepSeekApi.new @analysis = deep_seek_service.analyze_product(@product) ``` That's it! You have now integrated OpenAI with your **Lightning Rails** project and learned how to switch to **DeepSeek** using the same API wrapper. # Multi-Step Form Wizard Break long forms into manageable steps ### Overview The multi-step form wizard allows you to break long forms into manageable steps, improving the user experience by only displaying one step at a time. It's powered by a lightweight Stimulus.js controller and integrates seamlessly with `simple_form` and Tailwind CSS in Lightning Rails. ### Installation & Setup Follow these steps to implement a form wizard in your Lightning Rails project. #### 1. Create the Form View Wrap your form in a `

` and split it into multiple steps using `data-wizard-target="step"` on each section. ```erb

<%= form_with model: @model, local: true, html: { class: "space-y-4" } do |f| %>

<%= f.label :first_name, class: "label" %> <%= f.text_field :first_name, class: "input input-bordered" %>

<%= button_tag "Next", type: "button", data: { action: "click->wizard#goToNext", next_step: "1" }, class: "btn btn-primary" %>

<% end %>

``` #### 2. Create the Stimulus Controller Add this Stimulus controller in `app/javascript/controllers/wizard_controller.js`: ```sh rails g stimulus wizard ``` ```js import { Controller } from '@hotwired/stimulus' export default class extends Controller { static targets = ['step'] goToNext(event) { const nextStep = event.target.dataset.nextStep - 1 const actualStep = event.target.dataset.nextStep this.stepTargets[nextStep].classList.add("hidden") this.stepTargets[actualStep].classList.remove("hidden") } goToPrevious(event) { const previousStep = event.target.dataset.previousStep - 1 const actualStep = event.target.dataset.previousStep this.stepTargets[actualStep].classList.add("hidden") this.stepTargets[previousStep].classList.remove("hidden") } } ``` Make sure the controllers are registered in `application.js` : ```js // Configure your import map in config/importmap.rb. Read more: https://github.com/rails/importmap-rails import "@hotwired/turbo-rails" import "controllers" ``` ### Usage * Each step is wrapped in a `div` with `data-wizard-target="step"`. * Use `class="hidden"` (Tailwind utility) to hide inactive steps. * Navigation is handled via `button_tag` with `data-action` for Stimulus event bindings. * `next_step` and `previous_step` indicate the index of the step to show/hide. ### Best Practices * Keep each step concise and focused. * Validate inputs before allowing the user to proceed (add validations or checks in the controller if needed). * Use consistent styling with Tailwind to provide visual cues for step transitions. ### Troubleshooting **Issue:** Nothing happens when clicking "Next" or "Previous".\ **Solution:** * Ensure the Stimulus controller is properly registered and compiled. * Verify that `data-controller="wizard"` and `data-wizard-target="step"` are correctly placed. * Make sure the buttons have the correct `data-action`, `next_step`, or `previous_step`. **Issue:** Steps aren't hiding/showing properly.\ **Solution:** * Confirm that `class="hidden"` is being toggled correctly. * Check that `stepTargets` correspond to the order of steps in your HTML. *** Let me know on Slack if you'd like an enhanced version with progress indicators or form validation! # Internationalization I18n A quick guide to outline how to install and configure internationalization support in your Lightning Rails project for multi-language applications. {% embed url="" %} ### 🚀 Generate I18N config If you haven't generated the I18n config on setup, you can add it to your Lightning Rails project by running this command: ```bash bash generators/setup_I18n.sh ``` ### Features #### ✅ What's Included 1. **Multi-language Support**: English, Spanish, French, German 2. **Devise Integration**: Complete Devise translations for all languages 3. **Fixed Position Language Switcher**: Always accessible in the bottom-right corner 4. **Session-based Locale Switching**: No authentication required 5. **Comprehensive Translations**: Common UI elements, navigation, forms, errors #### 🎨 Language Switcher

The language switcher is positioned as a **fixed floating button** in the bottom-right corner of the screen: * **Location**: Fixed position, always visible * **Style**: DaisyUI primary button with shadow effects * **Accessibility**: Available on all pages without authentication * **Animation**: Smooth hover transitions ### 🔧 Technical Implementation This is coded automatically by the generator; feel free to look at the code to understand it and modify it to your own use. #### **ApplicationController Integration *****(Created by the generator)*** ```ruby class ApplicationController < ActionController::Base before_action :set_locale [...] private def set_locale I18n.locale = extract_locale || I18n.default_locale end def extract_locale parsed_locale = params[:locale] || session[:locale] || request.env['HTTP_ACCEPT_LANGUAGE']&.scan(/^[a-z]{2}/)&.first parsed_locale if I18n.available_locales.map(&:to_s).include?(parsed_locale) end def default_url_options { locale: I18n.locale == I18n.default_locale ? nil : I18n.locale } end end ``` ### 🔗 URL Structure The setup automatically creates clean, locale-prefixed URLs: * **English**: `yoursite.com/en/` (default) * **Spanish**: `yoursite.com/es/` * **French**: `yoursite.com/fr/` * **German**: `yoursite.com/de/` * **Language switching**: `yoursite.com/locale/fr` (redirects to `/fr/`) #### Automatic Redirects * `yoursite.com/` → `yoursite.com/en/` * `yoursite.com/pages` → `yoursite.com/en/pages` * `yoursite.com/locale/fr` → `yoursite.com/fr/` ### 📝 Using Translations #### In Views ```erb

<%= t('pages.home.title') %>

<%= t('welcome_message', name: @user.name) %>

<%= t('items', count: @items.count) %>

``` #### In Controllers ```ruby # Set flash messages flash[:notice] = t('users.updated_successfully') # Redirect with translation redirect_to root_path, notice: t('users.welcome_back') ``` #### In Models ```ruby # Validation messages validates :name, presence: { message: :blank } ``` ### 🎨 Customizing the Language Switcher #### Position The switcher is positioned with: ```css .fixed.bottom-4.right-4.z-50 ``` #### Styling * **Button**: `btn-circle btn-primary shadow-lg` * **Dropdown**: `shadow-2xl bg-base-100 rounded-box` * **Hover**: `hover:shadow-xl transition-shadow duration-200` #### Customization Edit `app/views/components/_language_switcher.html.erb` to: * Change position (e.g., `top-4` instead of `bottom-4`) * Modify styling (e.g., different button colors) * Add animations * Change icon ### 🌍 Adding New Languages 1. **Create locale file**: ```bash cp config/locales/en.yml config/locales/it.yml ``` 2. **Create Devise locale file**: ```bash cp config/locales/devise.en.yml config/locales/devise.it.yml ``` 3. **Update configuration** in `config/application.rb`: ```ruby config.i18n.available_locales = [:en, :es, :fr, :de, :it] ``` 4. **Add translations** to the new locale files ### 🔧 Troubleshooting #### Language switcher not showing * Check that the component is rendered in `app/views/layouts/application.html.erb` * Verify the component file exists at `app/views/components/_language_switcher.html.erb` #### Translations not working * Ensure locale files are in `config/locales/` * Check that the locale is in `config.i18n.available_locales` * Verify the translation key exists in the locale file #### Routes not working * Check that the locale change route is properly added * Ensure `LocaleController` exists and has `skip_before_action :authenticate_user!` ### 📚 Best Practices 1. **Use translation keys consistently** 2. **Group related translations** (e.g., `pages.home.title`, `pages.about.title`) 3. **Use interpolation for dynamic content** 4. **Test all languages** after adding new translations 5. **Keep translations organized** in logical sections ### 🚀 Advanced Features #### RTL Support For right-to-left languages, add CSS classes: ```erb ``` #### Number/Date Formatting ```ruby # In locale files number: currency: format: unit: "$" precision: 2 separator: "." delimiter: "," # In views <%= number_to_currency(@price) %> <%= l(@date, format: :long) %> ``` And voilà! We've given you a good start, but it's now up to you to continue with the internationalization of your app. Make sure to go page by page, adding the dynamic translation tags, and don't hesitate to use AI to help you. It's worth doing this operation in a branch on a client like Cursor, as it will make this lengthy process much faster. Happy translating! ᬍ # Heros All the components pre-built in LightningRails for FAQ sections - Design from DaisyUI, TailwindCss and Custom ### Hero center

To add a beautifully designed Hero section to your landing page, copy and paste this line of code where you need this section to appear in your html.erb page:

<%= render "components/hero" %>

### Hero with background

To add the Hero section with a background frame, copy and paste this code: ``` <%= render "components/hero_bg" %> ``` ### Hero image split

To add the Hero section with a background frame and a split view with image, copy and paste this code: ``` <%= render "components/hero_split" %> ``` *** ### See more Hero designs: * [HyperUi Hero](#user-content-fn-1)[^1] * [DaisyUI Hero](https://daisyui.com/components/hero/) [^1]: # FAQs All the components pre-built in LightningRails for FAQ sections - Design from DaisyUI + TailwindCSS + custom ### Basic FAQ

To add this section copy and paste the following code into your html.erb file: ``` <%= render "components/faq" %> ``` *** ### FAQ full width

If you prefer this design copy paste the following: ``` <%= render "components/faq_full" %> ``` More designs coming soon! 🚀 *** ### See more FAQ designs: * [HyperUi faq](https://www.hyperui.dev/components/marketing/faqs) * [DaisyUI faq](https://daisyui.com/components/collapse/) # cards All the components pre-built in LightningRails for cards - Design from DaisyUI ### Card Product

To use this card in your project, copy and paste the following card into your html.erb file: ``` <%= render "components/card_product_image" ``` *** ### Card without image

To use this card in your project, copy and paste the following card into your html.erb file: ``` <%= render "components/card_no_image" ``` *** ### See more card designs: * [HyperUi cards](https://www.hyperui.dev/components/marketing/cards) * [DaisyUI cards](https://daisyui.com/components/card/) # Testimonials All the components pre-built in LightningRails for testimonials - Design from DaisyUI, HyperUI or custom ### Love wall testimonials

To add this design to your page, add the following line: ``` <%= render "components/testimonials" %> ``` *** ### Testimonials horizontal

Custom design from HyperUI testimonials, adapted to DaisyUI

To add this design, copy and paste the following line: ``` <%= render "components/testimonials_horizontal" %> ``` # Call To Actions All the components pre-built in LightningRails for call to actions (CTAs) sections - Design from DaisyUI, HyperUI or custom ### Horizontal CTA

To add this design to your page, add the following line: ``` <%= render "components/cta_horizontal" %> ``` *** ### CTA with form

To add this design, copy and paste the following line: ``` <%= render "components/cta_form" %> ``` # Features All the components pre-built in LightningRails for Features showcase sections - Design from DaisyUI, HyperUI or custom

Left title and a grid with SVG's and descriptions of all the features

To add this design to your page, add the following line: ``` <%= render "components/features_grid" %> ``` {% hint style="info" %} **Pro Tip:** If you want to change the SVG icons, [checkout Lucile.dev icon's library](/features-setup/lucide-icons), built-in Lightning Rails by default. {% endhint %} # Sliplane Deploy A guide on how to deploy your LightningRails app to sliplane Sliplane is now my favorite hosting provider, it is very easy to deploy and you can have several apps under the same server, great if your apps haven't picked up momentum without having to spend hundreds of $ on Heroku servers. *** After doing the setup, Sliplane’s mental model is: 1. **Create a Server** (your machine) 2. **Create a Project** (a group for one app and its services) 3. Add services inside the project (Postgres, Redis, your Rails app from GitHub) 4. Add env vars, deploy, then optionally add a custom domain 5. Use the built-in console (SSH) when you need to run Rails commands {% hint style="info" %} Bonus: **you can host several apps on the same server**, which is awesome for keeping costs down. Each app is just another Project on that same Server. {% endhint %} *** ### 0. Prerequisites * Your Lightning Rails app is pushed to GitHub (main branch recommended) * You have a Sliplane account * You are ready to set production env vars (Cloudinary, OpenAI, Stripe, etc if your app uses them) from your `.env` file *** ### 1. Prepare your app (Choose based on your case)

💡 For updating existing apps

``` # One-time setup (if not already done) gh auth login # Fetch the Sliplane setup files and add them to your project # 1. Fetch the rake task gh api repos/LightningRails/lightning-rails/contents/lib/tasks/sliplane_setup.rake \ --jq '.content' | base64 -d > lib/tasks/sliplane_setup.rake # 2. Fetch the bash script gh api repos/LightningRails/lightning-rails/contents/bin/setup-sliplane \ --jq '.content' | base64 -d > bin/setup-sliplane # 3. Make the bash script executable chmod +x bin/setup-sliplane # 4. Commit the changes git add lib/tasks/sliplane_setup.rake bin/setup-sliplane git commit -m "Added Sliplane deployment setup" # 5. You're ready to deploy! rails sliplane:setup ```

🆕 For a new app

From your project root: ``` bin/rails sliplane:setup ```

This command will: * Create a production-ready `Dockerfile` * Create `.dockerignore` * Create `bin/docker-entrypoint` * Create `.env.example` * Generate a `SECRET_KEY_BASE` * Print all required environment variables * Show the Sliplane deployment checklist Then push your code: ``` git add . git commit -m "Prepare for Sliplane" git push origin main ``` That’s it on the code side. *** ### 2. Create a Server in Sliplane 1. Go to Sliplane 2. Click **Create Server** 3. Choose a region 4. Choose an instance size (start small, scale later) 5. Wait until the server is ready You can deploy multiple apps on the same server by creating multiple Projects. *** ### 3. Create a Project (your app) 1. Click **Create Project** 2. Name it something like: ``` myapp-production ``` Inside this project, you’ll add services. *** ### 4. Add a PostgreSQL service (Required) Inside your project: 1. Click **Add Service** 2. Choose **PostgreSQL** 3. Set it to **Private** (not public) ⚠️ 4. Add a Volume (Leave default) 5. Set (Leave default): * `POSTGRES_USER` * `POSTGRES_PASSWORD` (mark as Secret) * `POSTGRES_DB` 6. Add Deploy it. Once live, note the variables above and the internal hostname\ You’ll need it for `DATABASE_URL`. *** ### 5. Add Redis (Optional) If your app uses: * Caching * ActionCable * Very complex Background jobs * Sidekiq Then: 1. Add Service → Redis 2. Set to **Private** 3. Add a volume (optional) 4. Deploy If not, you can skip this and use a SolidQueue setup (Guide coming soon) *** ### 6. Add Your Rails App (Repository Service) Inside your project: 1. Click **Add Service** 2. Choose **Repository** 3. Connect your GitHub repo 4. Select branch (usually `main` or `master`) 5. Sliplane will detect your `Dockerfile` 6. ⚠️ Make sure the privacy toggle is set to TRUE! Or you won't be able to add a domain. Set (Default): * Public: **Enabled** * Protocol: **HTTP** * Healthcheck path: `/` Deploy. Sliplane will now build your Docker image and compile assets. *** ### 7. Add Environment Variables Go to your Rails service → Settings → Environment Variables. Add all the variables found in your `.env` file. #### Required ``` RAILS_ENV=production SECRET_KEY_BASE="Find this key in the terminal when you ran the script" RAILS_SERVE_STATIC_FILES=true RAILS_LOG_TO_STDOUT=true ``` #### Database URL Go to your PostgreSQL service and find the variables in "settings". Here is where we link our brand new PostgreSQL service with our brand new repository service. Build it using your Postgres service: ``` postgresql://USER:PASSWORD@INTERNAL_HOST_URL:5432/DB_NAME ``` Example shape: ``` postgresql://app_user:superSecret123@postgres-lhlg.internal:5432/production_db ``` Add it as: ``` DATABASE_URL=... ``` *** #### Third-Party Keys (if your app uses them) If your Lightning Rails app uses external services, add them here: Examples: * `CLOUDINARY_URL` * `OPENAI_API_KEY` * `STRIPE_PUBLIC_KEY` * `STRIPE_SECRET_KEY` * `POSTMARK_API_TOKEN` If it exists in your `.env` locally or in your previous hosting provider's config, it likely belongs here in production. *** ### 8. First Deploy Checklist Once deployed: * Visit your Sliplane URL (`*.sliplane.app`) * Confirm styles are loading * Test login / registration * Check logs if anything fails If styles are missing, make sure: ``` RAILS_SERVE_STATIC_FILES=true ``` is set. *** ### 9. Add a Custom Domain (Private Domain) To use your own domain: 1. Open your Rails service 2. Go to **Domains** 3. Add your domain (example: `app.yourdomain.com`) 4. Sliplane will show required DNS records Usually: * For subdomain → create a **CNAME** * For root domain → follow the exact record Sliplane provides Once DNS propagates, SSL is handled automatically. You can then update: ``` RAILS_HOST=app.yourdomain.com ``` in environment variables if needed. *** ### 10. Open Console (SSH) Useful for: * Running migrations * Seeding data * Rails console #### Step 1 – Add your SSH key In Sliplane account settings, add your public SSH key. #### Step 2 – Open the service console In your Rails service, click **Console / SSH**.\ Sliplane provides a ready-to-copy SSH command. Use that command. #### Step 3 – Navigate to the app directory ``` cd /your-app ``` #### Step 4 – Run commands ``` bundle exec rails db:migrate bundle exec rails db:seed bundle exec rails c ``` ***

💡 Migrate PostgreSQL DB from Heroku (Optional)

We assume: * Heroku app has a Postgres addon * Sliplane has an internal Postgres service (like `postgres-lhlg.internal:5432`) * You can run commands locally (recommended) *** ## Phase 1 — Freeze Heroku ### 1️⃣ Put Heroku in maintenance mode ``` heroku maintenance:on -a YOUR_HEROKU_APP ``` This prevents new writes while you migrate. *** ### 2️⃣ Take final backup (insurance) ``` heroku pg:backups:capture -a YOUR_HEROKU_APP heroku pg:backups:download -a YOUR_HEROKU_APP ``` You now have `latest.dump` locally. Keep it safe. *** ## Phase 2 — Restore to Sliplane (You already did this, but here’s the official version) ### 3️⃣ Use pg\_restore 17 locally ``` PGPASSWORD='YOUR_DB_PASSWORD' $(brew --prefix postgresql@17)/bin/pg_restore \ --verbose \ --clean --if-exists \ --no-owner --no-privileges \ -h YOUR_PUBLIC_DB_HOST \ -p YOUR_PUBLIC_DB_PORT \ -U postgres \ -d mydb \ latest.dump ``` Let it finish. *** ### 4️⃣ Verify restore ``` PGPASSWORD='YOUR_DB_PASSWORD' psql \ -h YOUR_PUBLIC_DB_HOST \ -p YOUR_PUBLIC_DB_PORT \ -U postgres \ -d mydb \ -c "\dt" ``` Then test row counts: ``` select count(*) from users; ``` Match with Heroku: ``` heroku run rails console -a YOUR_HEROKU_APP User.count ``` If counts match → DB migration successful. *** ## Phase 3 — Point Rails to Sliplane DB Now update your Sliplane Rails service: Use **internal DB URL** (important for security & performance): ``` postgresql://postgres:PASSWORD@postgres-q6uu.internal:5432/mydb ``` Set this as: ``` DATABASE_URL ``` in Sliplane environment variables. *** ### 5️⃣ Redeploy Rails app Then test: * Login works * New records save * Background jobs work * Stripe webhooks work * Emails send * ActiveStorage works Create a test record and delete it. *** ## Phase 4 — Switch Traffic If not already done: * Update DNS to Sliplane * Wait propagation * Confirm production domain works Monitor logs for 10–15 minutes. *** ## Phase 5 — Lock Down Database Very important. Once everything works: * Remove public DB access * Remove `0.0.0.0/0` * Make Postgres internal-only Your Rails app should now talk only via internal hostname. *** ## Phase 6 — Kill Heroku (After Confidence Window) Leave Heroku in maintenance mode for a few hours (optional safety buffer). When ready: ``` heroku apps:destroy -a YOUR_HEROKU_APP ``` Also remove: * Heroku Postgres addon * Heroku Redis * Any scheduler addons Double-check nothing else depends on it.

### Cost Optimization Tip You can host **multiple Lightning Rails apps on the same Sliplane server**. Each app: * Has its own Project * Has its own Postgres service * Shares the same server resources This keeps infrastructure simple and affordable. *** ### Summary Deploying Lightning Rails to Sliplane is: 1. Run one setup command 2. Create server 3. Add Postgres 4. Add Repository service 5. Paste env variables 6. Deploy Clean, simple, production-ready. # Heroku Deploy We currently use Heroku for deploying to production but LightningRails works with other popular options as well. We will add a guide to other ones very soon. To install Heroku CLI in your terminal, follow these instructions: ### macOS installation ```bash brew tap heroku/brew && brew install heroku heroku --version # It should display heroku/x.x.x ``` ⚠️ If you get this error: ```bash Bad CPU type in executable ``` Execute this command: ```bash softwareupdate --install-rosetta --agree-to-license heroku --version # Now it should display heroku/x.x.x ``` ### Ubuntu installation ```bash curl https://cli-assets.heroku.com/install.sh | sh heroku --version # It should display heroku/x.x.x ``` ### Login Signin from the terminal to be able to push directly from the terminal ```bash heroku login ``` ### Create your heroku app To create an app and automatically connect it to your current directory of code through the GitHub remotes: ```bash heroku create myawesomeapp --region eu ``` {% hint style="info" %} It's important to set the correct region, otherwise your methods like Time.now will have the wrong time zone, plus you might get in trouble down the line with cookies and users data storage 🍪 {% endhint %} ### Push to production After committing your last line of code, you can now push to production with a simple command ```bash git push heroku master ``` ### Migrate your database Remember that your development database is only in your computer and stored locally, heroku in turn is in the cloud, which means it will have a different database, that you must migrate and seed. ```bash heroku run rails db:migrate # Run pending migrations in production heroku run rails db:seed # Run the seed in production ``` ### Credential variables Along the same lines as we set our API keys in our credentials file and .env file, you must set it to your production environment ``` heroku config:set postmark_api=YOUR_API_KEY # repeat for all the API keys you have setup ``` ### Stripe credentials You will need to go to your stripe dashboard and toggle the "Live" button, to access the live api keys "developers" > API. Once done, copy the keys in your terminal with the following command to ```bash heroku config:set STRIPE_PUBLIC_KEY=**** heroku config:set STRIPE_PRIVATE_KEY=**** ``` You will also need to create a webhook under "Webhooks": 1. Click on "add an endpoint" 2. Add the endpoint url: *`"https://example.org/pay/webhooks/stripe"`* 3. Select events: Charge + checkout 4. Copy the key and paste it in your terminal with the following command ```bash heroku config:set STRIPE_SIGNING_SECRET=***** ``` ### Error Handling in Heroku If you run into an error when opening your app in the browser with ```bash heroku open ``` You will need to investigate by looking at the logs ```bash heroku logs --tail ``` # Security A section with guides on how to protect your rails app against attacks. **To protect your app against Bots:** {% content-ref url="/pages/cdX1835pbzpUUqjVfwwN" %} [Rate Limiting](/deploying-to-production/security/rate-limiting) {% endcontent-ref %} # Rate Limiting Implementing Rate Limiting in Your Ruby on Rails App with rack-attack Implement rate limiting using the rack-attack gem to enhance the security of your Rails application and prevent abuse. This gem helps throttle excessive requests and block abusive traffic efficiently. Follow these step-by-step instructions to integrate **rack-attack** into your Lightning Rails app. ### **Step 1: Add the rack-attack Gem** First, add the [**rack-attack** gem](https://github.com/rack/rack-attack) to your `Gemfile`: ```ruby gem 'rack-attack' ``` Then, install the gem by running: ```sh bundle install ``` ### **Step 2: Configure rack-attack** Now, configure the rate limiting rules by creating an initializer file: ```sh touch config/initializers/rack_attack.rb ``` Open the file and add the following configuration: ```ruby class Rack::Attack # Throttle requests from the same IP address to 5 requests per second throttle('req/ip', limit: 5, period: 1.second) do |req| req.ip end # Block IPs that fail authentication too many times Rack::Attack.blocklist('block bad IPs') do |req| Rack::Attack::Fail2Ban.filter("bad-ips", maxretry: 5, findtime: 1.minute, bantime: 5.minutes) do req.ip if req.path == "users/sign_in" || "users/sign_up" && req.post? end end # Allow whitelisted IPs to bypass rate limits safelist('allow from localhost') do |req| '127.0.0.1' == req.ip end # Log blocked requests ActiveSupport::Notifications.subscribe("rack.attack") do |name, start, finish, request_id, payload| Rails.logger.info "[Rack::Attack] Throttled: #{payload[:request].ip}" if payload[:request] end end ``` This configuration: * Limits all requests to **5 per second per IP**. * Blocks IPs that exceed **5 failed login attempts within a minute**. * Allows **localhost (127.0.0.1)** to bypass rate limits, you can add other IPs if needed * Logs blocked requests for monitoring on your production server. This last point was very usefull to me as when I suspected a bot attack, I checked the IP address and realised it was Google's IP address trying to index my site 😅 ### **Step 3: Test Your Configuration** 1. **Restart Your Server**\ Run the following command to apply the changes: ```sh shCopyEditrails restart ``` 2. **Monitor Logs**\ Check your Rails logs (`log/development.log`) to see if any IPs are being throttled or blocked: ```sh shCopyEdittail -f log/development.log ``` If rate limits are hit, you will see messages like: ``` cppCopyEdit[Rack::Attack] Throttled: 192.168.1.100 ``` 3. **Adjust Limits** * Modify the `limit` and `period` values to suit your needs. * Tweak `maxretry`, `findtime`, and `bantime` for authentication-related restrictions. * Add **custom rules** to protect specific endpoints like API requests. *** ### **Step 4: Deploy and Monitor** Once tested locally, deploy your changes to production. Monitor logs and adjust limits based on real-world traffic patterns. You can also integrate **Redis** for better performance with large-scale applications. *** ### **Final Thoughts** By following these steps, you've successfully added rate limiting to your Rails app using **rack-attack**. This helps prevent abuse, enhance security, and optimize resource usage efficiently. Happy coding! 🚀 # Error Monitoring with Sentry Receive errors directly on your email with Sentry free plan.

Sentry is a powerful error tracking tool that helps you monitor and fix crashes in real-time. Adding it to your Lightning Rails project gives you instant visibility into production issues with stack traces, request context, and more. ### Installation The Sentry SDK for Rails comes as two gems. Add them to your `Gemfile`: ```ruby gem "sentry-ruby" gem "sentry-rails" ``` Then install the gems: ```bash bundle install ``` *** ### Configure SDK Generate the initializer with: ```bash rails generate sentry ``` This creates `config/initializers/sentry.rb`. Now edit the generated file to include your configuration: ```ruby if Rails.env.production? Sentry.init do |config| config.dsn = 'https://8f1bc0b22a55bb483283e664f9fb421f@o4509708042043392.ingest.us.sentry.io/4509789067608064' config.breadcrumbs_logger = [:active_support_logger, :http_logger] # Add data like request headers and IP for users, # see https://docs.sentry.io/platforms/ruby/data-management/data-collected/ for more info config.send_default_pii = true end end ``` > 💡 Make sure to only enable this in production by wrapping it in `if Rails.env.production?` , we don't want to spam our email with error messages when developing ;) *** ### Verify It’s Working You can test the setup by triggering a sample error in the production console. ```ruby begin 1 / 0 rescue ZeroDivisionError => exception Sentry.capture_exception(exception) end Sentry.capture_message("test message") ``` This should send both the exception and the message to your Sentry dashboard. *** ### Optional: Trace Propagation (Frontend + Backend) If you're using frontend Sentry, you can enable distributed tracing by leaving this in your layout: ```erb <%= Sentry.get_trace_propagation_meta.html_safe %> ``` It should have been added to your header when you used the generator above. `` tag in `app/views/layouts/application.html.erb`. Happy Bug Tracking! 🐛🦟🕷️🪲 # MetaMask Authentication Sign in with MetaMask (SIWE) using OmniAuth OpenID Connect

This guide adds “Sign in with MetaMask” (Sign-In with Ethereum, **SIWE**) to your Lightning Rails app using **Devise** + **OmniAuth OpenID Connect**. It keeps your regular Devise auth and adds a wallet-based login. No private keys ever touch your server—users only sign a message. You’ll: * Install and configure OmniAuth OIDC * Register an OIDC client for **development** and **production** * Add a Devise callback controller * Store the user’s **wallet address** and show it in the navbar ### 1) Add gems ```ruby # Gemfile gem "omniauth" gem "omniauth-rails_csrf_protection" gem "omniauth_openid_connect", ">= 0.8.0" ``` ```bash bundle install ``` *** ### 2) Add User fields Generate and run the migration to store the wallet address and a timestamp: ```bash rails g migration AddWeb3ToUsers wallet_address:string last_siwe_at:datetime bin/rails db:migrate ``` If you prefer the exact file from the PR: ```ruby # db/migrate/xxxxxx_add_web3_to_users.rb class AddWeb3ToUsers < ActiveRecord::Migration[8.0] def change add_column :users, :wallet_address, :string add_index :users, :wallet_address add_column :users, :last_siwe_at, :datetime end end ``` *** ### 3) Make your Devise model omniauthable ```ruby # app/models/user.rb class User < ApplicationRecord devise :database_authenticatable, :registerable, :recoverable, :rememberable, :validatable, :omniauthable, omniauth_providers: [:openid_connect] end ``` > We use the provider name `:openid_connect` to match routes and callback. *** ### 4) OmniAuth configuration Create the OmniAuth initializer and allow POST/GET (GET helps during local testing; you can lock to POST later). ```ruby # config/initializers/omniauth.rb Rails.application.config.middleware.use OmniAuth::Builder do provider :openid_connect, name: :openid_connect, # Devise works best with this name scope: %i[openid profile], response_type: :code, issuer: ENV.fetch("SIWE_ISSUER"), # e.g. https://oidc.login.xyz/ discovery: true, client_options: { identifier: ENV.fetch("SIWE_CLIENT_ID"), secret: ENV.fetch("SIWE_CLIENT_SECRET"), redirect_uri: ENV.fetch("SIWE_REDIRECT_URI") } end ``` ```ruby # config/initializers/omniauth_protection.rb OmniAuth.config.allowed_request_methods = %i[post get] ``` *** ### 5) Devise routes ```ruby # config/routes.rb devise_for :users, controllers: { omniauth_callbacks: "users/omniauth_callbacks" } ``` This generates: * Authorize: `/users/auth/openid_connect` * Callback: `/users/auth/openid_connect/callback` *** ### 6) OmniAuth callbacks controller Generate the controller: ```bash rails g controller users/omniauth_callbacks ``` Replace its content with: ```ruby # app/controllers/users/omniauth_callbacks_controller.rb module Users class OmniauthCallbacksController < Devise::OmniauthCallbacksController def openid_connect auth = request.env["omniauth.auth"] || {} info = auth["info"] || {} extra = auth["extra"] || {} raw = (extra["raw_info"] || {}) # userinfo claims # Common places SIWE providers put the address (varies by issuer) addr = (info["address"] || raw["address"] || raw["wallet_address"] || auth["uid"]).to_s.downcase if addr.blank? Rails.logger.warn("SIWE: missing address. auth=#{auth.inspect}") redirect_to new_user_session_path, alert: "Wallet address missing from SIWE response" return end user = User.find_or_initialize_by(wallet_address: addr) if user.new_record? user.email = "eth-#{addr}@example.invalid" # or prompt later user.password = Devise.friendly_token[0, 32] end user.last_siwe_at = Time.current user.save! sign_in_and_redirect user, event: :authentication set_flash_message(:notice, :success, kind: "MetaMask") if is_navigational_format? rescue => e Rails.logger.error("SIWE callback error: #{e.class} #{e.message}") redirect_to new_user_session_path, alert: "Sign-in failed" end def failure redirect_to new_user_session_path, alert: "Sign-in canceled" end end end ``` *** ### 7) Add the “Sign in with MetaMask” button On your Devise sessions page (Lightning Rails’ sign-in): ```erb # app/views/devise/sessions/new.html.erb <%= button_to user_openid_connect_omniauth_authorize_path, method: :post, data: { turbo: false }, class: "btn btn-primary gap-2 mt-4" do %> Sign in with MetaMask <% end %> ``` > OmniAuth 2 prefers **POST** for the authorize request; using `button_to` handles that. *** ### 8) Show the wallet in the navbar (optional) Helper: ```ruby # app/helpers/application_helper.rb module ApplicationHelper def truncate_address(address) return "" unless address.present? core = extract_core_address(address) "0x...#{core[-4..]}" end def extract_core_address(address) return "" unless address.present? # Handle eip155:1:0xabc... if address.include?(":") parts = address.split(":") return parts.last if parts.last.start_with?("0x") end address.start_with?("0x") ? address : "0x#{address}" end end ``` Navbar snippet: ```erb # app/views/shared/_navbar.html.erb (or your layout’s nav) <% if user_signed_in? && current_user.wallet_address.present? %> <%= truncate_address(current_user.wallet_address) %> <% else %> <%= link_to "Get started", new_user_registration_path, class: "btn btn-primary" %> <% end %> ``` *** ### 9) Environment variables (.env) Lightning Rails already loads `.env`. Add these: ``` # Development issuer (example: login.xyz) SIWE_ISSUER=https://oidc.login.xyz/ SIWE_CLIENT_ID=your_dev_client_id SIWE_CLIENT_SECRET=your_dev_client_secret SIWE_REDIRECT_URI=http://localhost:3000/users/auth/openid_connect/callback ``` > **Important:** the redirect path **must** match your provider name `:openid_connect`.\ > If you change the provider name to `:siwe`, use `/users/auth/siwe/callback` and update all references. *** ### 10) Register your OIDC client You need a client **per environment** (dev and prod). Most SIWE OIDC issuers support dynamic registration. #### Development registration (example) ```bash curl -X POST 'https://oidc.login.xyz/register' \ -H 'Content-Type: application/json' \ --data '{ "redirect_uris": ["http://localhost:3000/users/auth/openid_connect/callback"] }' ``` You’ll receive JSON with `client_id` and `client_secret`. Put them in your **dev** `.env`. #### Production registration Use your production domain: ```bash curl -X POST 'https://oidc.login.xyz/register' \ -H 'Content-Type: application/json' \ --data '{ "redirect_uris": ["https://YOUR_DOMAIN.com/users/auth/openid_connect/callback"] }' ``` Add the prod values to your production environment (e.g., Render/Heroku/Fly secrets) as: ``` SIWE_ISSUER=https://oidc.login.xyz/ SIWE_CLIENT_ID=your_prod_client_id SIWE_CLIENT_SECRET=your_prod_client_secret SIWE_REDIRECT_URI=https://YOUR_DOMAIN.com/users/auth/openid_connect/callback ``` > If you use another issuer (e.g., `https://oidc.signinwithethereum.org/`), the steps are identical—just change `SIWE_ISSUER` and the registration URL. *** ### 11) Sanity checks After you’ve set everything: ```bash rails routes | grep openid_connect ``` You should see: ``` user_openid_connect_omniauth_authorize /users/auth/openid_connect(.:format) user_openid_connect_omniauth_callback /users/auth/openid_connect/callback(.:format) ``` Common fixes: * **Routing error for `/auth/...`**Your Devise routes live under `/users/auth/...`. Make sure the **registered redirect URI** matches exactly. * **“Mapping omniauth\_callbacks on a resource that is not omniauthable”**: ensure `:omniauthable` and `omniauth_providers: [:openid_connect]` are in `User`. * **Path helper not found**: ensure the **provider name** matches in the initializer, model, controller method, and the button helper. *** ### 12) What you have now * Users can sign in with MetaMask (SIWE) via a trusted OIDC provider. * You store their **wallet address** on the `users` table. * You can display it in the UI and later fetch balances/holdings. From here, you can add: * A “Link/Unlink wallet” page * ETH balance fetch on the dashboard * Parallel **Solana** login (Phantom) if you want multi-chain auth That’s it—SIWE is live in your Lightning Rails app. # Updating your project How to Update Your LightningRails Project This guide shows you how to safely update your existing LightningRails project to get the latest features, bug fixes, and improvements. You can decide to update the [whole project with our Update Script](#update-script-heavy-conflicts-resotution), or cherry-pick specific Pull requests. ### 📋 Prerequisites Before you start, make sure you have: * ✅ A clean git working directory (commit or stash your changes) * ✅ A backup of your project (or be on a feature branch) * ✅ 5-10 minutes of time * ✅ Basic familiarity with git commands ### 📃 UPDATE SCRIPT (Heavy conflicts resotution) #### 🚨 For Projects Before v1.5.0 (Before July 2025) If your LightningRails project was created before v1.5.0, you won't have the update script yet. Don't worry - we'll get you set up! #### Option 1: Download the Script (Recommended) From your project's root directory ```bash # Make generators directory mkdir generators # One-time setup per user gh auth login # Fetch the update file and add it to your folder gh api repos/LightningRails/lightning-rails/contents/generators/update_project.sh \ --jq '.content' | base64 -d > generators/update_project.sh # Commit this change ga . && gc -m "Added generator folder" # You're ready to go! bash generators/update_project.sh ``` ### 🚀 How to Use the Update Script #### Step 1: Choose to Apply Updates When prompted, choose option 1 to apply all updates.

#### Step 3: Resolve Conflicts (If Any) If you get merge conflicts, here's the general rule of thumb: 📁 For View Files (your customizations): * Keep YOUR CURRENT changes in app/views/ files * These contain your branding and custom content ⚙️ For Config Files (framework updates): * Keep Most INCOMING changes in config/ files * These contain important framework updates 🔍 Always check case by case - don't blindly accept all changes from either side. #### Step 4: Complete the Update After resolving conflicts, commit the merge `git commit -m "Update: Merge latest LightningRails improvements"` Install any new dependencies `bundle install` Run any new migrations `rails db:migrate` Test your application `dev` ### 🍒 Cherry picking specific PRs If you don't want to update the whole project, but bring a specific PR to your project. 1. **Add the Lightning Rails repo as a remote:** ```bash git remote add lightning-rails https://github.com/LightningRails/lightning-rails.git git fetch lightning-rails ``` 2. **Find the commit(s) in the PR:** From the PR page: \ At the time of writing, the main commit is likely something like: ```bash # Example (replace with actual commit SHA from the PR) git cherry-pick abcdef1234567890 ``` You can see this by clicking the “Commits” tab in the PR and grabbing the SHA(s). 3. **Resolve any conflicts** and commit the changes. 4. **Remove the remote (optional):** ```bash git remote remove lightning-rails ``` ### 🆘 Quick Troubleshooting If something breaks after updating: Return to your backup `git checkout backup-before-update-[timestamp]` If you're unsure about a conflict: * When in doubt, keep your current changes for anything customer-facing * Keep incoming changes for technical/framework files ### 💡 Pro Tips * Update regularly - smaller, frequent updates are easier than big ones * Test immediately - catch issues early * Update during low-traffic times - be safe with production updates That's it! The script handles the complex parts - you just need to make smart decisions about which changes to keep. *** Remember: Your customizations in views are precious - protect them. Framework updates in config files are usually safe to accept. Happy updating! # Design Resources A collection of Free resources to help you pimp your Rails app