DEV Community: Darrian Bagley

Simultaneous “has_many” and “has_many :through” Associations using Rails ActiveRecord

Darrian Bagley — Sat, 06 Aug 2022 07:24:00 +0000

We can connect two tables using multiple associations simultaneously. For example: User has_many: :tasks and User has_many: :tasks, through: :projects. There are a lot of potential uses for this method. I'll be using an example task management application in which Users have a direct connection to Tasks they create and an indirect association to Tasks that are in Projects that have been shared with them by other Users.

TL;DR Solution

To establish multiple associations between two tables, use a different name for the attribute and use the source property to define the table being connected. We can use has_many, :through to define an indirect association and has_many to create a direct association.

  has_many :tasks`
  has_many :project_tasks, through: :projects, source: :tasks

Next, I recommend creating a model method to access all of a User’s Tasks. Keep in mind that the two collections may overlap, so we’ll use the uniq method to remove duplicates:

  def all_qr_codes
    (self.qr_codes + self.shared_qr_codes).uniq
  end

Note: In my examples, I’m using Rails 7.0.3.1. Other versions may not support this syntax, but the principles still apply.

Explanation

That’s the short answer, now into the details. Let’s create relationships between three models in a hypothetical task management application.

Here’s our end goal:

Users will be able to create Tasks and Projects.
Users will be able to add Tasks to Projects.
Users will be able to add other Users to Projects. The tricky part:
Not every task will be part of a project, so Users need a direct association with Tasks.
Users won’t have a direct association with Tasks that are related to Projects that have been shared by other Users. This will require an indirect has_many :through association.

We want to give Users a has_many relationship with Tasks, a has_many relationship with Projects, and a has_many :through relationship connecting Users to Tasks through Projects. However, if you try to add both to the User model using the name :tasks for both associations, Rails won’t be able to process the migration. That’s why using a different name for the has_many :through relationship works.

Next up, I’ll walk you through creating this schema from start to finish. These instructions assume you’ve already created a Rails project and have a basic understanding of Ruby on Rails.

Step 1: Creating the Tables and Models

We’ll create basic models for Users, and Projects, Tasks. I recommend using Rails generators if you know how to, but here’s what the corresponding database migrations should look like (with bare minimum fields). We’ll start with the migrations to create tables for the models:

class CreateUsers < ActiveRecord::Migration[7.0]
  def change
    create_table :users do |t|
      t.string :username
      t.timestamps
    end
  end
end

class CreateTasks < ActiveRecord::Migration[7.0]
  def change
    create_table :tasks do |t|
      t.string :title
      t.belongs_to :user
      t.belongs_to :project, optional: true
      t.timestamps
    end
  end
end

class CreateProjects < ActiveRecord::Migration[7.0]
  def change
    create_table :projects do |t|
      t.string :title
      t.timestamps
    end
  end
end

Step 2: Many-to-Many: Projects and Users via Join Table

To create our many-to-many relationship between Users and Projects, we can use a join table. You can run:

rails generate migration CreateProjectsUsersJoinTable projects users

The resulting migration creates a table called projects_users. Each record will store 2 foreign keys defining a connection between a user and a project:

class CreateProjectsUsers < ActiveRecord::Migration[7.0]
  def change
    create_table :projects_users do |t|
      t.references :user, foreign_key: true
      t.references :project, foreign_key: true
      t.timestamps
    end
  end
end

We need to add these lines to the models (pay attention to the order of associations, we have to connect to projects_users before we connect to projects through it):

class User < ActiveRecord::Base
  has_many :projects_users
  has_many :projects, through: :projects_users
end

class Project < ActiveRecord::Base
  has_many :projects_users
  has_many :users, through: :projects_users
end

Step 3: One-To-Many: Users and Tasks Direct Association

Let’s add has_many :tasks to the User model and the Project model. Be sure you’ve added the t.belongs_to :user and t.belongs_to :project columns to the Tasks table which will store the foreign keys. Then we can add these lines to the models:

class User < ActiveRecord::Base
  has_many :projects_users
  has_many :projects, through: :projects_users
  has_many :tasks
end

class Project < ActiveRecord::Base
  has_many :projects_users
  has_many :users, through: :projects_users
  has_many :tasks
end

class Task < ActiveRecord::Base
  belongs_to :user
  belongs_to :project
end

Step 4: One-To-Many: Users and Tasks Indirect Association through Projects

Finally, to create the has_many :through relationship between Users and Tasks through Projects, we’ll add this line to the User model:

class User < ApplicationRecord
  has_many :projects_users
  has_many :projects, through: :projects_users
  has_many :tasks
  has_many :project_tasks, through: :projects, source: :tasks
end

And, as I mentioned before, we can create a model method to query all of a User’s Tasks. Keep in mind that the two collections may overlap, so we’ll use the uniq method to remove duplicates:

  def all_qr_codes
    (self.qr_codes + self.shared_qr_codes).uniq
  end

What is a Direct Association?

A direct association is when a record has a column containing the ID of another record it has a relationship with. This is usually the case for one-to-many relationships where the child model has a column containing the ID of the parent model. Here’s an example of a one-to-many direct relationship in Rails:

class Author < ApplicationRecord
  has_many :books
end

class Book < ApplicationRecord
  belongs_to :author
end

What is an Indirect Association?

Indirect associations are used to define a relationship between two records through a mutual record they’re connected to. This is often used to create join tables. In the following example, Physicians and Patients are connected through mutual appointments. Appointments have a one-to-many direct association with Physicians and Patients. By using “through:” a many-to-many indirect relationship is created between Physicians and Patients who share an appointment.

class Physician < ApplicationRecord
  has_many :appointments
  has_many :patients, through: :appointments
end

class Appointment < ApplicationRecord
  belongs_to :physician
  belongs_to :patient
end

class Patient < ApplicationRecord
  has_many :appointments
  has_many :physicians, through: :appointments
end

And that’s it! Hopefully this explanation has helped you configure your Rails database and clarified how has_many and has_many :through can be used to create direct and indirect associations. If you know a better solution to connect Users to Tasks through projects and directly, leave a comment and let me know!

Ruby Methods to Increase your Programming Efficiency

Darrian Bagley — Tue, 05 Jul 2022 22:06:18 +0000

Using the right Ruby methods can save you a lot of work. The more methods you are familiar with the faster you can produce working code & the better this code will be, both in performance & quality. To improve your productivity, here are some helpful methods that you may not have seen before.

Prefix & Suffix Methods

start_with? & end_with? return boolean results based on whether the beginning or end of a string match the provided string.
delete_suffix and delete_prefix remove from the beginning or end of a string if the suffix or prefix match the provided string.

Percent String Literals

Besides %(...) which creates a String, the % may create other types of object. As with strings, an uppercase letter allows interpolation and escaped characters while a lowercase letter disables them. For the two array forms of percent string, if you wish to include a space in one of the array entries you must escape it with a “\” character.
These are the types of percent strings in ruby:
%i - Array of Symbols
%q - String
%r - Regular Expression
%s - Symbol
%w - Array of Strings
%x - Backtick (capture subshell result)

Convert Number to an Array of Digits

the digits method returns an array of a number's digits in reverse.
123.digits => [3, 2, 1]

The Object Tap Method

The tap method allows you to perform an action on an object then return the object.
Instead of:

user = User.new
user.name = "John"
user

You can write:

User.new.tap { |user| user.name = "John" }

The new object will be returned after performing the operation which avoids using a temporary variable.

Transforming Multiple Hash Values

When you need to transform all of the values in a hash, say doubling your inventory, you can use the transform_values method.
Instead of:

inventory = {item_A: 200, item_B: 300}
inventory.each { |k,v| h[k] = v*2 }

You can use:

inventory = {item_A: 200, item_B: 300}
inventory.transform_values! { |v| v * 2 }
{:item_A=>400, :item_B=>600}

Protecting Private API Keys using a Simple Proxy Server

Darrian Bagley — Sat, 28 May 2022 22:03:02 +0000

Two common mistakes developers make when using a private API key in their application are:

Including the API key in the source code
Including the API key in client-side HTTP requests

Revealing private API keys and authorization tokens to users through client-side HTTP requests and in your source code exposes you and your application to a high risk of abuse. If a malicious user uses your API key for their application, it can cost you money and potentially prevent you from using the API by exceeding your usage limits.

To avoid this, it’s recommended that you perform any requests that require authentication from the back-end of your application (a server) rather than the browser. However, if you need to make requests on the fly on the client-side, a quick way to accomplish this more securely is to use a proxy server to wrap requests with the necessary headers/query parameters containing your keys.

What is a Proxy Server?

A proxy server acts as a middle-man between your application and the API. There are 3 steps:

You send a request to the server.
The server sends that request to the API.
The server responds to your request with the response from the API.

The proxy server I’m going to demonstrate here is only slightly more secure than using your keys in the browser as, without further precautions (such as domain restrictions), other users could simply make requests through your proxy. I’ll explain further precautions you can take at the end of this post.

Basic Proxy Server Example

Here’s an example proxy server I wrote using Deno. I used Deno for because Deno Deploy is offering free hosting while it's in public beta (as of May 2022). If you visit Deno Deploy and start a playground project, you can try this out for yourself using this code!

If you're using Node, the same principles apply, but you'll have to rewrite the code to use Express or another Node-based web application framework.

This server makes requests to the Twitter API. To authenticate my requests, I must include an “Authorization” header with a bearer token as its value. I'll send requests to the proxy server and it will attach the Authorization header and send the request to the API.

To make my requests through the proxy, I’ll replace the API domain with my server's domain.

Here's an example:

My server is hosted at https://my-project.deno.dev
I want to send a request to the Twitter API at https://api.twitter.com/2/tweets?ids=1261326399320715264

To send the request via my proxy server from my application, I would use this combined URL: https://my-project.deno.dev/2/tweets?ids=1261326399320715264

import { serve } from "https://deno.land/std@0.137.0/http/server.ts";

const bearer = "Bearer MYBEARERTOKEN";

async function handler(req) {
  const url = new URL(req.url);
  const pathname = url.pathname;

  // Replace server domain with Twitter API domain for the proxy request
  const fetchURL = `https://api.twitter.com${pathname}${url.search}`;

  // Only make proxy request if there is a URL path
  if (pathname.length > 1) {
    const res = await fetch(fetchURL, {
      headers: { Authorization: bearer }
    });

    // If there is a response body, send it as text to the application.
    if (res.body) {
      return new Response(await res.text(), {
        headers: { "Access-Control-Allow-Origin": "*" }
      });
    }
  }
  // If there is no URL path, display "Hello World"
  return new Response("Hello World");
}

serve(handler);

Further Precautions

As I mentioned earlier, this simple proxy server will prevent users from seeing your private API keys in your source code and HTTP requests, but a user might still make requests using your proxy server.

A precaution you can take to prevent this is to restrict requests from other domains. Simply change the Response header "Access-Control-Allow-Origin" from "*" to the hostname you want to accept requests from. Example: { "Access-Control-Allow-Origin": "https://www.google.com" }

And that's it! If you have any thoughts on this method of protecting API credentials or other precautions you recommend, please mention them in the comments below!

Creating a Free Static API using a GitHub Repository

Darrian Bagley — Mon, 25 Apr 2022 02:04:11 +0000

Most APIs on the web are dynamic, meaning they're capable of generating, updating, and transforming content in response to requests. A static API is simply a collection of files (typically JSON) that are hosted online and can be accessed via HTTP request by an application. Unlike a dynamic API, a static API is unable to perform actions.

Why use a Static API

Because dynamic APIs require you to run an application on a server, they can be expensive and difficult to maintain (especially at scale). Sometimes your application needs to access data via HTTP requests but doesn't need the other functionality an API can provide. If that's you, a static API can save you time and money, especially if you make use of a free static hosting solution, like GitHub.

When to use a Static API

Consider using a static API if:

You don't need to authenticate requests
You only need to deliver pre-made content
Actions don't need to be triggered by requests
The content is not updated frequently

How to use GitHub to Create Your Static API

To create a static API, all you need is to host JSON files somewhere online. Here's how you can do so for free using a GitHub repository:

1. Create your JSON files.

Create a JSON file containing the data you want each request to return. Name the files descriptively so you know what you're requesting in your code.

2. Create a public GitHub repository.

If you've never used GitHub, you'll need to create a free account. Here's the documentation on how to create a repository.

3. Upload your JSON files to the repository.

Here's documentation on how to upload files.

4. Access your files via URL.

The easiest way to do this is using GitHub RAW file URLs, HOWEVER, this is not best practice. In your final application, it's highly recommended that you use GitHub Pages, which will serve your files via CDN for better performance. I'll explain both methods.

Method 1: GitHub Pages (Recommended)

GitHub Pages is GitHub's free static hosting solution. Follow their documentation on how to enable GitHub Pages in your repository. Don't worry about giving your website a theme as the appearance of the site won't matter.

Once you've set up GitHub Pages in your repository, access your JSON files using this URL pattern: https://.github.io///

Method 2: GitHub RAW File URLs

This method doesn't require any additional setup. The URL to your raw file will look like this:
https://raw.githubusercontent.com/////

Example: https://raw.githubusercontent.com/github/platform-samples/master/LICENSE.txt

In the above example, the user "github" has a repository named "platform-samples" with a branch named "master" that contains the file "LICENSE.txt" in the root directory.

If the file is in a folder in the repository, rather than the root directory, remember to include the path in the URL. Example: https://raw.githubusercontent.com/github/platform-samples/master/sql/metrics/actions-summary.sql

Additional Notes

You can use GitHub raw file links to access files from any public GitHub repository, not just your own. If someone else has made data available for public use, this can be a great way to access it if they haven't made it available via an API (or if their API doesn't suit your needs).

HOWEVER The owner of the repository could modify or remove their files at any point. To avoid changes breaking your application, fork the repository and fetch the data from your fork instead.