DEV Community: Code Salley

React Native & Fastlane

Code Salley — Fri, 07 Mar 2025 16:25:55 +0000

React Native CI/CD with Fastlane (iOS)

Code Salley ・ Mar 7

#reactnative #cicd #fastlane #programming

React Native CI/CD with Fastlane (iOS)

Code Salley — Fri, 07 Mar 2025 16:23:30 +0000

React-Native app CI/CD to increment build number, build, and publish. This part is focused on iOS to keep things simple.

Requirements

React Native App
Fastlane
Apple developer account

The plan is to rely on the app store connect API, to avoid 2FA nightmare. First, we need to create an API key for our Fastlane script.

Create an API key

Go to app store connect and click on users and access select integrations tab and add a new team key (give it a name and set access to App Manager).
Download the key and take note of the (Key Id and Issuer Id)
In total, we have 3 env variables here

Table 1.0

Name	Value	Description
APPSTORE_KEY_PATH	`/certs/example.p8`	path to key file
APPSTORE_ISSUER_ID	1234-5454-test.....	Issuer ID under team keys
APPSTORE_KEY_ID	3B3XXS9XXX	Key id from generated key

Now let's head over to our project and install fastlane, check out fastlane docs for the best way to install. I will go with Bundler,

STEP1 (only if you are using bundler)
If you don't have a Gemfile in the root of your project, create one and add fastlane

Gemfile

# Gemfile
source "https://rubygems.org"

gem "fastlane"

Then run bundle install, now we have fastlane installed. Keep in mind, if you install fastlane with bundler you have to run fastlane with bundle exec fastlane if you're using homebrew no need to prepend bundle exec.

STEP 2.
Initialize fastlane by running the below command, this will create a folder and a fastfile for you.

bundle exec fastlane init

This will generate a fastlane folder with a Fastfile and Appfile.

Now we need a way to generate and manage certificates securely, I recommend using match and git(GitHub)
Let's add match to our workflow by running

bundle exec fastlane match init

this will generate a Matchfile which will house match configurations.
add your git repo, app_identifier, and app store username to the Matchfile. it will look something like this

# fastlane/Matchfile
#
# create a private GitHub repo and paste the URL here.
# you can create a classic GitHub API key and have your repo looking like 
# git_url("https://GIT_BASIC_AUTHORIZATION@github.com/username/awesome-app-certs.git")
git_url("https://github.com/username/awesome-app-certs.git")

storage_mode("git")

app_identifier("com.example")
username("username@example.com")

Time to automate our lanes to run straight, we are following these simple steps

create a keychain db

connect to app store connect and get an API key using envs in Table 1.0

codesigning with match

Increment build number (optional)

Build app

push to Testflight

1.create a keychain db

# I recommend passing keychain-name and keychain-password through env.
# delete old keychain if one exists
delete_keychain(
  name: keychain-name
) if File.exist? File.expand_path("~/Library/Keychains/keychain-name-db")

  # create a new keychain, take note of the name and password
create_keychain(
  name: keychain-name,
  password: keychain-password,
  default_keychain: true,
  unlock: true,
  timeout: 3600
)

2.connect to app store connect and get an API using envs in Table 1.0

api_key = app_store_connect_api_key(
  key_id: ENV['APPSTORE_KEY_ID'], # from table 1.0
  issuer_id: ENV['APPSTORE_ISSUER_ID'],  # from table 1.0
  key_filepath: ENV['APPSTORE_KEY_PATH'],  # from table 1.0
  in_house: false
)

3 codesigning with match

match(
  type: "appstore", # use development | appstore | ad-hoc
  app_identifier: 'com.example', # if you have other extensions like oneginal then pass an array [com.example, com.example.OneSignalNotificationServiceExtension]
  verbose: true,
  api_key: api_key,
  keychain_name: keychain-name,
  keychain_password: keychain-password
)

4 Increment build number

# getting app version number
# [https://docs.fastlane.tools/actions/get_version_number/]
version = get_version_number(
  xcodeproj: "ios/ExampleApp.xcodeproj", # path to xcodeproj 
  target: "exampleApp" # Target name
 )

# get the current build number of a version from Testflight using api_key from step 2.
# [https://docs.fastlane.tools/actions/latest_testflight_build_number]
current_build_number = latest_testflight_build_number(version: version, api_key: api_key, app_identifier: "com.exmaple")

# [https://docs.fastlane.tools/actions/increment_build_number/]
increment_build_number(
  xcodeproj: "ios/exampleApp.xcodeproj",
  build_number: current_build_number + 1
 )

5 Build app docs

# build app with gym
 build_app(
   scheme: "exampleApp",
   workspace: "ios/exampleApp.xcworkspace",
   export_method: "app-store",
   clean: true,
   verbose: true,
     export_options: {
       export_method: "app-store",
       team_id: '123TEAM_ID',
     }
 )

6 Publish to Testflight

upload_to_testflight(
  skip_waiting_for_build_processing: true,
  api_key: api_key,
  changelog: "New Build"
)

By putting all these together, we have enough steps to build and publish our app. To Keep things short, below is the link to the complete Faslane file.
Fastlane gist

Ruby most useful Hash methods

Code Salley — Sun, 24 Mar 2024 18:07:45 +0000

Since almost everything in ruby is an object, you get tons of feature that makes data manipulation easier. Ruby hash is one of the data types and is easy to work with. And if you are looking to work with a key and value pair, the hash is the way to go. Here are some of the useful hash methods to know.

`Hash#fetch`

Fetch method allows you to retrieve a value from a hash using a key. If the key is not found in the hash, you can specify a default value to return instead of nil.

person = { "name" => "John", "age" => 30, "city" => "New York" }

person.fetch("name")
# John

# Provided default value is returned instead of nil
# when the value is not found
person.fetch("country", "Unknown")
# Unknown

`Hash#dig`

dig method allows you to access nested values in a hash without having to check for the existence of each key in the chain. The dig method takes a list of keys as arguments and returns the value at the specified key path.

person = {
  name: "John",
  age: 30,
  address: {
    street: "123 Main St",
    city: "New York",
    country: "USA"
  }
}

name = person.dig(:name)
city = person.dig(:address, :city)
country = person.dig(:address, :country)
state = person.dig(:address, :state)

# Name: John
# City: New York
# Country: USA
# State: nil

`Hash#then`

then method, you can chain methods together and pass the result of one method to the next method as an argument. The then method is called on the object and takes a block as an argument. The block is called with the object as the argument, and the block's return value is the result of the method chain.

even_numbers = [2, 4, 6, 8, 10]

def add_ten_to_even_numbers(numbers)
  numbers.map { |num| num + 10 }
end

add_ten_to_even_numbers(even_numbers).then { |new_num| puts new_num.inspect }
# [12, 14, 16, 18, 20]

`Hash#value?`

value? method allows you to check if a hash contains a specific value. The method returns true if the value is found in the hash, and false otherwise. This takes out the complexity of trying to loop through a hash.

person = { name: "John", age: 30, city: "New York", country: "GH", code: "GH"}

hash.value?(30)
# true 

hash.value?(31)
# false

just an addon, values_at method allows you to retrieve the values of multiple keys from a hash.

hash.values_at(:age, :city, :country)
# [30, "New York", "GH"]

`Hash#tap`

allows you to "tap into" a method chain, and do something with the object that is being passed along the chain. The block is called with the object as the argument and the block's return value is ignored.

valid_names = ["John", "Smith", "Jane", "Doe", "Mick", "Jagger", "Sam", "stone"]
guest_names = [ "Doe", "Jagger", "Khamil", "Paul"]

def check_guest_names(guest_names, valid_names)
  [].tap do |x|
    guest_names.each do |name|
      x << name if valid_names.include?(name)
    end
  end
end

response = check_guest_names(guest_names, valid_names)
puts response.inspect
# ["Doe", "Jagger"]

(1..10).to_a.select { |x| x.even? }.tap { |x| puts "Even #{x}" }
# Even [2, 4, 6, 8, 10]

Hope it was helpful, and beware of the bang(!)

Ruby on Rails api authentication with devise and Doorkeeper

Code Salley — Fri, 30 Dec 2022 20:25:49 +0000

Ruby on Rails web authentication with devise is easy to get started with, but how can we handle authentication with devise and doorkeeper in a rails api. This article focuses on steps to add authentication after creating a new project.

Buckle up, required gems installation, Starting with devise.

Setup devise

# add to Gemfile
gem 'devise'

# install gem
bundle install 

# devise initialization.
# for more context on devise refer to official 
rails generate devise:install

# generate User model migration. 
rails generate devise User 

# Run rails migration 
rails db:migrate

Devise docs

Setup Doorkeeper

# add doorkeeper to Gemfile 
gem 'doorkeeper'

# install gem 
bundle install 

# initialize doorkeeper 
rails generate doorkeeper:install 

# Above command integrate doorkeeper into your 
# project and create and initializer file in 
# config/initializers/doorkeeper.rb, add doorkeeper 
# routes to your route file(config/routes.rb) and locale 
# file in config/locales/doorkeeper.en.yml 
# for more insight check official docs. 

# generate doorkeeper migration 
rails generate doorkeeper:migration

# run rails migration 
rails db:migrate

Doorkeeper Official docs

We need two(2) routes for login and signup. In config/routes.rb lets comment out use_doorkeeper and devise routes. Create new routing to look something like this.

# config/routes.rb

# comment or remove doorkeeper routes
# use_doorkeeper

# not exposing devise routes 
devise_for :users, only: [] 

# our auth routes auth/signup and auth/login
scope "auth" do 
  post "/signup",  to: "auth#signup"
  post "/login",  to: "auth#login"
end

doorkeeper configuration needs some adjustment since we're using custom routes.

# config/initializers/doorkeeper.rb

Doorkeeper.configure do
  # Change the ORM that doorkeeper will use (requires ORM extensions installed).
  # Check the list of supported ORMs here: https://github.com/doorkeeper-gem/doorkeeper#orms
  orm :active_record

  # This block will be called to check whether the resource owner is authenticated or not.
  resource_owner_authenticator do
    current_user || warden.authenticate!(scope: :user)
  end

  resource_owner_from_credentials do |_routes|
    User.authenticate!(params[:email], params[:password]) # we need to add this method in our user model
  end

  grant_flows %w[authorization_code client_credentials password]

  use_refresh_token

  client_credentials :from_basic, :from_params

  access_token_methods :from_bearer_authorization, :from_access_token_param, :from_bearer_param

  access_token_expires_in 1.hour
end

lets adjust User model to include authenticate! method

# app/models/user.rb
class User < ApplicationRecord

# add this method to find and authenticate users
  def self.authenticate!(email, password)
    user = find_by(email: email.downcase)
    user if user&.valid_password?(password)
  end
end

One of the very capabilities of doorkeeper is the ability to manage multiple platforms, like a doorkeeper client app for android, web etc. In our database seed (db/seeds.rb) lets create an app for our IOS app like this.

# db/seeds.rb

Doorkeeper::Application.find_or_create_by(name: "IOS APP") do |app|
  app.redirect_uri = "urn:ietf:wg:oauth:2.0:oob"
  app.secret = "my_secret" 
  app.uid = "my_uid"
  app.save!
end

run rails db:seed to insert above doorkeeper app into our database.

Now we need auth controller to be able to handle requests from our signup and login routes. create a file app/controllers/auth_controller.rb

# app/controllers/auth_controller.rb

# signup method
def signup
    client_app = Doorkeeper::Application.find_by(uid: params[:client_id])

    unless client_app
      return render json: { error: I18n.t("doorkeeper.errors.messages.invalid_client") },
          status: :unauthorized
    end

    @user = User.new(user_params)
    @user.save


    unless @user
      render json: { message: "registration failed" }, status: :unprocessable_entity
    end

    @results = model_results(@user, client_app)

    @results
end

def login
    response = strategy.authorize
    @token = response.status == :ok ? response.token : nil
    if @token&.resource_owner_id
      @user ||= User.find(@token.resource_owner_id)
    end

    self.response_body =
      if response.status == :unauthorized
        render json: {error: "unauthorized" }, status: 404
      else
        user_json(@user, @token)
      end
end



private 

# for a more cleaner approach, separate this into concerns or an isolated class.

def model_results(user, client_app, token_type = "Bearer")
   access_token = Doorkeeper::AccessToken.find_or_create_for(
        resource_owner: user.id,
        application:    client_app,
        refresh_token:  generate_refresh_token,
        expires_in:     Doorkeeper.configuration.access_token_expires_in.to_i,
        scopes:         ""
      )

  return { user: user, tokens: {refresh_token: access_token.refresh_token, access_token:  access_token.token }
end


 def generate_refresh_token
    loop do
      token = SecureRandom.hex(32)

      break token unless Doorkeeper::AccessToken.exists?(refresh_token: token)
    end
end


def user_json(user, token)
    {
      user:          user,
      auth: {

        access_token:  token.token,
        refresh_token: token.refresh_token
      }
    }.to_json
end

  def user_params
    params.require(:user).permit(:email ,:password, :password_confirmation)
  end

Finally how do we secure endpoints?
For any controller actions we desire to protect, we place this in our controller.

class ProfileController < ApplicationController
  # this protects profile actions. 
  before_action :doorkeeper_authorize!


  def create 
  end
end

Happy Coding 🎉

Ruby require argument keyword

Code Salley — Wed, 28 Sep 2022 10:37:07 +0000

Working with Ruby there are times you want a method to have required arguments without chaining multiple if else statements

A simpler and easy way to handle required arguments is,


# define a method with named arguments like this results in an 
# error when name is not provided

def greetGuest(name:)
  puts "Welcome #{name}!"
end

# invoking method without name will throw ArgumentError
greetGuest # ArgumentError: missing keyword: name


greetGuest(name: "Salley" ) # Welcome Salley!

And even better you can have default arguments like:


def greetGuest(name: "Anonymous Guest")
  puts "Welcome #{name}!"
end

# invoking method without name will use the default argument
greetGuest # Welcome Anonymous Guest!

Enjoy!

Twitter

Ruby on Rails(ROR) development environment setup(Mac OS)

Code Salley — Sat, 07 May 2022 16:57:02 +0000

Ruby on Rails is a Ruby framework for building full-stack web applications, created by David Heinemeier Hansson.

Setting up your macOS for Ruby on Rails development requires you to have ruby, ruby on rails gem installed and a compatible database mostly PostgreSQL or MySQL, Most ruby on rails applications you might work on don't use the latest ruby version. We will need a ruby version manager which will enable switching between different ruby versions

⚠️ Prerequisites ⚠️ ___ ### Xcode command line tools:

Install by pasting this into your terminal

xcode-select --install

### Homebrew

Allow us to access and install a wide variety of software and command-line tools from the console, I prefer homebrew because it's easy to get started with. Enter the following in your terminal to download homebrew

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Visit homebrew to learn more.

### Git

A version control system that allows us to track, revert and commit changes to files within a directory. Let's install it and add a user.

# install git
brew install git

# this will mark you as the 'author' of each committed change
git config --global user.name "your name here"

# use the email associated with your GitHub account
git config --global user.email your-email-address

### Ruby + Rbenv

Rbenv is a version manager for ruby, Of course, we've other alternatives like rvm, asdf ..., Rbenv is easy to get started with and I recommend it for beginners.

# install rbenv
brew install rbenv

# add to the PATH (rbenv commands are now available from terminal)
# .bashrc (or .zshrc for Catalina+ users) is the file that contains 
# all of our terminal settings
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
# CATALINA+ USERS:
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.zshrc


# initialize rbenv every time you open a new console window (otherwise 
# our system ruby version will take over when we start a new terminal session)
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
# CATALINA+ USERS:
echo 'eval "$(rbenv init -)"' >> ~/.zshrc

# update current console window with new settings
source ~/.bashrc
# CATALINA+ USERS:
source ~/.zshrc

# source .bashrc from .bash_profile (unnecessary for CATALINA USERS)
echo 'source ~/.bashrc' >> ~/.bash_profile

# install Ruby version 2.5.1
rbenv install 2.5.1

# set version 2.5.1 to be our global default
rbenv global 2.5.1

# the 'rehash' command updates the environment to your configuration
rbenv rehash

# and let's verify everything is correct
# check the version
ruby -v # => 2.5.1

# check that we are using rbenv (this tells you where the version of ruby you are using is installed)
which ruby # => /Users/your-username/.rbenv/shims/ruby

### Useful Gems

For debugging purposes, I recommend a few gems that will get you started and allow you to play with ruby code in your terminal and manage ruby gems. Gems like bundler pry and byebug do it good and you can check out the official docs, Pry, Byebug, Bundler,
These gems need to be accessed globally.

Bundler allows us to define project dependencies inside a Gemfile and gives us a bunch of commands to update, remove and install them.
Pry is an alternative to the Irb (the default Ruby REPL). It is not only more powerful, but also easier to use than Irb and should be your go-to for running and debugging Ruby code.
Byebug is a feature-rich debugging tool for Ruby. With Byebug you can halt the execution of your code and inspect/track variables and the flow of execution.

We can install them by

gem install bundler pry byebug

Enjoy!

Twitter

Ruby on Rails event invitation add to calendar using icalendar gem

Code Salley — Sat, 22 Jan 2022 19:13:17 +0000

In rails sending an event invitation is simple, But getting an invite recognized by Gmail for easy "add to calendar" feature is tricky. After experimenting with it for a while, this simple config does the trick.

require 'icalendar/tzinfo'
class EventMailer < ApplicationMailer
 def send_invitation(_user, _event)

  # initialize a new icalendar class
  ical = Icalendar::Calendar.new

  # Define default time
  time_zone = 'UTC'
  cal_tz = TZInfo::Timezone.get time_zone

  # add timezone to icalendar 
  ical.add_timezone cal_tz

  # new icalendar event 
  event = Icalendar::Event.new

  # event start date
  event.dtstart = Icalendar::Values::DateTime.new _event.start_time, 'tzid' => cal_tz

  # event end date
  event.dtend = Icalendar::Values::DateTime.new _event.end_time, 'tzid' => cal_tz


  # event organizer
  event.organizer = Icalendar::Values::CalAddress.new("mailto:" + _user.email)

  # event created date
  event.created = DateTime.now

  # event location
  event.location =  _event.venue

  # if there's an external link e.g, google meet
  event.uid = event.url = _event.meeting_link


  # event title
  event.summary = _event.title


  # event description
  event.description = _event.description


  # attach the configured event to icalendar class
  ical.add_event(event)


  # protocol
  ical.append_custom_property("METHOD", "REQUEST")

  # this add's an attachment name `event.ics`, 
  # when clicked, the event gets added to the calendar. 

  mail.attachments['event.ics'] = { mime_type: 'application/ics', content: ical.to_ical }


  # send mail
  mail(to: _user.email, subject:  "#{_event.title} - #{_event.summary} ")
 end
end

enjoy!

Basic Auth with Ruby on Rails(Faraday gem)

Code Salley — Sun, 28 Nov 2021 11:46:30 +0000

Faraday gem comes in handy with several plugins(middleware) that make HTTP request easier and more customisable, Basic authentication in ruby turn to be tricky. let's digest it;

require "faraday"

request_helper = Faraday.new(url: 'example.com') do |builder|
                builder.use Faraday::Request::BasicAuthentication, client_key, secret_key
             end

# you make HTTP requests using `request_helper` since basic auth is configured

response = request_helper.get('/myendpoit')

Using an API like PAYPAL API, you need to get tokens by proving client and secret keys. With Faraday::Request::BasicAuthentication middleware we can pass client and secret keys as arguments to achieve basic authentication using the same method above.

twitter: code salley

Multi-Tenancy with Nodejs and mongoDb

Code Salley — Fri, 29 Oct 2021 19:04:55 +0000

The main concept of multi-tenancy is privacy and data segregation, With MongoDB architecture ( Database and collections ). It’s easy to allocate collection for tenants database

You should have a simple npm application setup and install mongoose by running;



npm install mongoose --save

Implement a logic to handle MongoDB database connection and switching. In this scenario I will use two different approaches, switching between database's using useDb and disconnect and reconnect ( this is useful for test cases only )

Connect and disconnect approach




// mongoose import 
const Mongoose = require('mongoose')

// a function that takes database name and database url as import and return a mongoose connection
const connectDb = async (dbName, dbUrl) => {

if (dbName === Mongoose.connection?.db?.databaseName) return Mongoose

  try {
    Mongoose.connection.close()
    const mongoose = await Mongoose.connect(dbUrl, { useNewUrlParser: true })
    mongoose.connection.once('open', () =>
      log.info(`mongodb connected to ${dbUrl}`)
    )
    return mongoose
  } catch (error) {
    log.error(error)
  }
}
module.exports = { connectDb }

with the above usage, all we need is the database name and database URL, We check the database name to see if it's already open, if open we just return mongoose object else we close all open connections and reconnect to the database using the URL we passed in.

useDb(recommended) approach




// mongoose import 
const Mongoose = require('mongoose')

// a function that takes database name and database url as import and return a mongoose connection
const connectDb = async (dbName, dbUrl) => {

if (dbName === Mongoose.connection?.db?.databaseName) return Mongoose

  try {
    if( Mongoose.readyState == 1 ) {
        return Mongoose.useDb(dbName)
    } else {
    const mongoose = await Mongoose.connect(dbUrl, { 
                           useNewUrlParser: true })
    mongoose.connection.once('open', () =>
      log.info(`mongodb connected to ${dbUrl}`)
    )
    return mongoose.useDb(dbName)
}

  } catch (error) {
    log.error(error)
  }
}
module.exports = { connectDb }

A very simple approach, with useDb all we need is an open connection or create a new connection then return a new instance of MongoDB by passing the database name to the useDb function from an open MongoDB connection. In other cases you might have separate models(schema) for tenants, Here is an example.



// connect to mongodb
const mongoose = await Mongoose.connect(dbUrl, { 
                           useNewUrlParser: true })

// connect to prefer database
const db =  mongoose.useDb(databaseName)

// use model(schema) preferred
db.model(modelName, schema)

Keep tenants locked up!!

twitter: code salley

Ruby on Rails API Simple authentication with JWT

Code Salley — Thu, 23 Sep 2021 21:19:30 +0000

Implementing a simple JWT authentication in a rails application with less configuration. The idea is to have a middleware that checks token in the request headers object to verify token before allowing user access to secure controller methods.

Here we've sessions controller responsible for LOGIN and SIGNUP, and a todos controller to perform CRUD.

but first, let's create a new rails API by running



rails new todoApi --api

and generate our models



#Users model 

rails generate model user email:string password:string

#Todos model 

rails generate model todo title:string 

# run migration 

rails db:migrate

and install jwt by adding



gem 'jwt'

to Gemfile

and inside application_controller.rb we define our authentication methods since all controllers inherit from application controller



class ApplicationController < ActionController::API
  SECRET = "yoursecretword"

  def authentication
    # making a request to a secure route, token must be included in the headers
    decode_data = decode_user_data(request.headers["token"])
    # getting user id from a nested JSON in an array.
    user_data = decode_data[0]["user_id"] unless !decode_data
    # find a user in the database to be sure token is for a real user
    user = User.find(user_data&.id)

    # The barebone of this is to return true or false, as a middleware
    # its main purpose is to grant access or return an error to the user

    if user
      return true
    else
      render json: { message: "invalid credentials" }
    end
  end

  # turn user data (payload) to an encrypted string  [ A ]
  def encode_user_data(payload)
    token = JWT.encode payload, SECRET, "HS256"
    return token
  end

  # turn user data (payload) to an encrypted string  [ B ]
  def encode_user_data(payload)
    JWT.encode payload, SECRET, "HS256"
  end

  # decode token and return user info, this returns an array, [payload and algorithms] [ A ]
  def decode_user_data(token)
    begin
      data = JWT.decode token, SECRET, true, { algorithm: "HS256" }
      return data
    rescue => e
      puts e
    end
  end

  # decode token and return user info, this returns an array, [payload and algorithms] [ B ]
  def decode_user_data(token)
    begin
      JWT.decode token, SECRET, true, { algorithm: "HS256" }
    rescue => e
      puts e
    end
  end
end

now let's add a few configuration to our routes and sessions controller

in routes.rb



Rails.application.routes.draw do
  post "/login", to: "sessions#login"
  post "/signup", to: "sessions#signup"

  resources :todos

end

in sessions_controller.rb



class SessionsController < ApplicationController
  def signup
    user = User.new(email: param[:email], password: password[:password])

    # if user is saved
    if user.save
      # we encrypt user info using the pre-define methods in application controller
      token = encode_user_data({ user_data: user.id })

      # return to user
      render json: { token: token }
    else
      # render error message
      render json: { message: "invalid credentials" }
    end
  end

  def login
    user = User.find_by(email: param[:email])

    # you can use bcrypt to password authentication
    if user && user.password == param[:password]

      # we encrypt user info using the pre-define methods in application controller
      token = encode_user_data({ user_data: user.id })

      # return to user
      render json: { token: token }
    else
      render json: { message: "invalid credentials" }
    end
  end
end

we can now secure controller methods by using a controller callback and authentication method in application_controller.rb



class TodosController < ApplicationController

# authentication is the method we define in application_controller.rb to check request.headers['token']

  before_action :authentication

  # GET /todos
  def index
    @todos = Todo.all

    render json: @todos
  end
end

easy peasy..

twitter: code salley

Ruby Single Table Inherency (STI)

Code Salley — Sat, 11 Sep 2021 08:49:50 +0000

From a personal experience, In a recent interview for a rails developer position, i was asked to implement something simple but tricky. eg:

"We need an application to create a post, comments, and replies with only two tables, how will you approach it."

All i could think of was creating a boolean column in comments table to trigger replies. After the session, the interviewer gave me a straight tip on what he expected and that's single table inheritance(STI).
We've 'Posts table' and 'Comments table', after generating our models and migrating, we can create another class 'Replies' to inherit from 'Comments'. eg

Post model

Rails generate model post title:string

above we generate a model Post with a title column.

Comments model

Rails generate  model comment title:string type:string

above is a comments model with title and type, you might be wondering why type? well, we need a column to hold replies type. creating a reply will be saved as a type.

let's generate a replies model.

Rails generate model reply --parent=Comment

Yes, about the flag used --parent a normal model inherits from active record by default but here we want our model to inherit from Comment model, adding the flag generate something like this

class Reply < Comment
end

we can comments and replies

# comment
comment = Comment.create(title: "hello comment")

reply
# reply = Reply.create(title: "hello title")

Reply SQL looks like

INSERT INTO "comments" ("type", "title") VALUES ('Reply', 'hello title')

You should always try to avoid Single Table Inherency(STI), it makes models associations complicated

Rails redirect user to the previous page after signup or login

Code Salley — Wed, 11 Aug 2021 14:34:16 +0000

Let's hit the ball, After working on a subscription platform for a while I realized new user's who wanted to pay for service's on the go have to sign up but after signup, Devise redirect the user to the root page, user's will have to look up what they wanted all over again.

devise allows us to override most of the implementation,
we can create a registration controller.

class Users::RegistrationsController < Devise::RegistrationsController



 protected


  def after_sign_up_path_for(resource)
     url = session[:fall_back_url]
       session[:fall_back_url] = nil
      if current_user && url
        url
      end
  end
end

And inside controller methods we might what to save user's url, we'll save it an session fall_back_url

def show
    if !current_user
      session[:fall_back_url] = request.url
    end
end