DEV Community: Takehiro_Yamazaki

Rails Meets GraphQL: How to Master context and find_by with Examples

Takehiro_Yamazaki — Sun, 23 Mar 2025 05:33:00 +0000

Introduce

Ever wondered how to fetch data in Rails with GraphQL without overcomplicating things? You’ve got two trusty tools: context and find_by. Choosing the right one can make your code cleaner, your queries faster, and your app easier to maintain.

In this guide, I’ll break down their differences, walk you through real examples, and share some lessons learned from working with both in production.

⚠️ Note: This guide is based on my own experience. Depending on your project’s architecture, there might be some nuances or edge cases not covered here.

🔍 What’s the Deal with `context` and `find_by`?

Let’s start with the basics—what each one actually does.

🕵️‍♂️ `find_by`: The Database Detective

Searches the database based on given conditions.
Executes a fresh query every time—no caching.
Returns nil if no match (use find_by! to raise an error instead).
Doesn’t rely on model relationships—works anywhere.

🤝 `context`: The Request Sidekick

Stores temporary data shared across a GraphQL request.
Holds things like context[:current_user] for quick access.
Helps avoid redundant database calls by reusing already-fetched data.
Especially useful for accessing data tied to the logged-in user.

✅ When `context` Saves the Day

If you're fetching data tied directly to the authenticated user, context is your best friend.

Example: Fetching a User Profile

# File: app/graphql/types/auth_query_type.rb
module Auth
  module Types
    class AuthQueryType < Base::Types::BaseObject
      field :user_profile, Auth::Types::ProfileType, null: false,
            description: "Gets the current user's profile."

      def user_profile
        # Grabs the profile via the user’s relationship—no extra query needed
        context[:current_user].profile
      end
    end
  end
end

Why it works:

Since context[:current_user] is already loaded, calling .profile just uses the ActiveRecord association—no additional database hit. This is perfect for performance-sensitive routes.

🔎 When `find_by` Takes the Lead

Sometimes you need more control—specific filters, IDs, or permissions. That’s where find_by comes in.

Example: Finding a Post by ID

# File: app/graphql/types/auth_query_type.rb
module Auth
  module Types
    class AuthQueryType < Base::Types::BaseObject
      field :post, Auth::Types::PostType, null: false do
        argument :id, ID, required: true
      end

      def post(id:)
        # Finds a post matching the ID and user, throws an error if not found
        Post.find_by!(id: id, user_id: context[:current_user].id)
      end
    end
  end
end

Why use find_by!?

You're filtering not just by ID, but also by user_id—something relationships alone can't express. And with find_by!, you make sure an error is raised if the post doesn’t exist. (Use find_by if you’re okay with getting nil.)

🧠 Your Cheat Sheet for Choosing

Scenario	`context` ✅	`find_by` ✅
Fetching logged-in user data	✅	❌
Searching by a specific ID	❌	✅
Accessing data via relationships	✅	❌
Adding custom filters	❌	✅
Handling records that might be nil	❌	✅

Rule of thumb:

Use context for relationship-driven access. Use find_by when you need fine-grained filters or extra logic.

💭 My Two Cents from the Trenches

After using both in real-world Rails + GraphQL apps, here’s how I approach the decision:

🔄 Why I Reach for `context`

def profile
  context[:current_user].profile # Clean, quick, done
end

If the data is tied to a user and you already have the user loaded, context gives you a fast, elegant solution. I’ve seen it reduce database queries significantly.

🔍 Why `find_by` Still Has Its Place

def published_post(post_id:)
  Post.find_by(id: post_id, status: 'published') # Filters like a champ
end

Need filters? Want to find data that may or may not exist? Dealing with permissions? That’s find_by territory.

🚀 Wrapping Up: Your Action Plan

Here’s how to apply what you’ve learned:

Use context[:current_user] when working with logged-in user relationships.
Use find_by when:
- You need to filter with custom conditions.
- You're fetching another user’s data (with proper permission checks).
- A record might not exist and you need graceful handling.

Mastering this distinction keeps your codebase clean, performant, and maintainable.

📚 Further Reading

【Docker & Rails】How to Securely Modify Database Migrations 🐳

Takehiro_Yamazaki — Tue, 18 Mar 2025 02:57:24 +0000

How to Safely Update Rails Migrations in a Docker Environment

In Rails development, you may occasionally need to change the data type of a column after running migrations.

This article explains how to safely alter table structures in a Rails application within a Docker environment. We’ll demonstrate this by changing the price column in a Books table from string to integer.

Initial Table Structure

Consider the following migration has already been executed:

class CreateBooks < ActiveRecord::Migration[7.1]
  def change
    create_table :books do |t|
      t.string :price

      t.timestamps
    end
  end
end

However, you might later realize you need numerical handling for price values.

Recommended Approach (Creating a New Migration)

Rails recommends adding a new migration instead of directly modifying existing ones.

Step 1: Generate a new migration file in Docker

In Docker environments, Rails commands should be run inside the container:

docker compose exec web bundle exec rails generate migration ChangeBooksPriceToInteger

This creates a new migration file:

db/migrate/20250314000000_change_books_price_to_integer.rb

Step 2: Edit the migration file

Open the generated migration file and define the type change clearly:

class ChangeBooksPriceToInteger < ActiveRecord::Migration[7.1]
  def up
    change_column :books, :price, :integer
  end

  def down
    change_column :books, :price, :string
  end
end

up method: Defines changes applied when running migrations.
down method: Defines changes applied during rollbacks.

Step 3: Run the migration in Docker

Apply the changes to the database:

docker compose exec web bundle exec rails db:migrate

Now, the price column of the Books table has been updated to the integer type.

Important Notes

Always verify that changing column types won't cause data inconsistency in environments with existing data, especially in production.
For non-critical data in development environments, rolling back and re-running the initial migration is possible, but adding a new migration is safer for production systems.

Summary

In Docker environments, always run Rails migration commands inside the container.
Safely change Rails migrations by adding new migration files rather than altering existing ones.
Clearly define changes and rollbacks using up and down methods.

This summarizes how to safely update existing Rails migrations in a Docker environment.

References

Active Record Migrations

How to Toggle Auto-Completion in Cursor Editor 🎉

Takehiro_Yamazaki — Tue, 26 Nov 2024 13:31:44 +0000

Background

Around November 2024, the Cursor Editor was updated to include Auto-Completion. This is a fantastic feature, but sometimes you might want to disable it temporarily. This guide explains how to do just that.

https://www.cursor.com/

Prerequisite

This guide is for MacBook users.

Steps to Disable Auto-Completion

Open the Cursor Editor and press cmd + shift + p.
Type "disable cursor tab".
Press Enter to apply the change.

Before

When auto-completion is enabled:

After

Once you type "disable cursor tab" and press Enter, auto-completion will be disabled:

How to Re-Enable Auto-Completion

To turn auto-completion back on:

Open the Cursor Editor and press cmd + shift + p.
Type "enable cursor tab".
Press Enter to apply the change.

Reference

https://forum.cursor.com/t/quick-disable-enable/15587/4

🎨 CI/CD Workflow with AWS and Docker

Takehiro_Yamazaki — Tue, 14 May 2024 01:10:04 +0000

Introduction

Hello, I'm Take, an engineer working at a product development company in Tokyo.

In this article, I will illustrate the overall structure of a CI/CD workflow utilizing AWS ECR/ECS, Docker, and GitHub Actions. I won't delve into specific setup steps but will focus on how these technologies are integrated and provide a visual explanation.

Key Technologies Used

VSCode: Editor for coding
GitHub Actions: Automates builds and tests upon code changes
Docker: Tool for containerizing applications
AWS ECR (Elastic Container Registry): Manages Docker container images
AWS ECS (Elastic Container Service): Manages containers and orchestrates them

Overall Process (tool:Excalidraw)

Developers make changes in VSCode and push them to GitHub.
GitHub Actions triggers, executing builds and tests, and uses Docker to create container images.
These images are stored in AWS ECR and then deployed via AWS ECS.

Detailed Explanation by Part

From Code Push to GitHub Actions

Developers push changes from their local branch to the GitHub repository with the following commands:

git add .
git commit -m "commit message"
git push origin HEAD

This triggers GitHub Actions, which automatically performs builds and tests, during which Docker creates a container image.

From GitHub Actions to AWS ECR

Once the build and tests succeed, the Docker image is uploaded to AWS ECR.

Think of ECR as a service that manages Docker images, offering secure access control and private networking. It’s a vital part of automating and securing the workflow from development to deployment.

From AWS ECR to ECS

The Docker image saved in ECR is then pulled by ECS, executing necessary initializations through an entrypoint.sh script.

"Pull" refers to the process of ECS retrieving container images from the ECR to start containers, managing applications with precise version control.

From ECS to Application Deployment

This section focuses on the concept of "kick," which in ECS terms, means a specific task has started running.

It's a step where the new task instances are launched based on task definitions, deploying the container images as live containers, ensuring the application operates as expected.

Conclusion

Thank you for reading this far! If you enjoyed this article, I'd really appreciate it if you could give it a 'Like' 🎉

💎 Using Ruby's SecureRandom to Strengthen User Authentication

Takehiro_Yamazaki — Sun, 12 May 2024 13:47:42 +0000

Introduction

Hi, I'm Take, and I work as an engineer at an in-house development company in Tokyo.

In this article, I'll share what I've learned about generating tokens necessary for secure user authentication using Ruby’s standard library, SecureRandom.

Background

What is SecureRandom?

SecureRandom is a tool used to generate random numbers and strings that are hard to predict. You can learn more about it in this helpful article here.

What is a Token?

A token is a randomly generated string used temporarily to identify a user.

What is a Digest?

During authentication, the data sent is transformed using the same hash function and verified against the stored digest, which is kept on the server side.

Comparing Tokens and Digests

Feature	Token	Digest
Purpose	Temporarily stored in the user's browser and used directly for authentication.	Stored in the database and used for token verification.
Generation Method	Generated using random data functions like `SecureRandom.urlsafe_base64`.	Generated from the token using hash functions like `SHA-256`.
Security	Randomly generated, but can be misused if stolen.	Stored in a hashed form, making it difficult to identify the original token if stolen.

Generating a Token

The SecureRandom.urlsafe_base64 method generates a safe, random token. This method produces a 22-character string from a set of 64 possible characters (A-Z, a-z, 0-9, "-", "_").

irb(main):001> SecureRandom.urlsafe_base64
=> "TGYseMGxXvuG4tmD08MiAQ"
irb(main):002> SecureRandom.urlsafe_base64
=> "a_xN8Hw0BMuRHrGszl-CLA"
irb(main):003> SecureRandom.urlsafe_base64
=> "AUMBKxwWbV0eMGGEP2LNJg"

Generating a Digest

The token generated is hashed using the User.digest method, and this hashed version (digest) is stored in the database. This makes it difficult to identify the actual token if it were ever leaked.

def remember
  self.remember_token = User.new_token
  update_attribute(:remember_digest, User.digest(remember_token))
end

This method generates a new token and saves it to the remember_token property of the user instance before updating the token’s digest in the remember_digest field.

User Authentication Process

When a user revisits the site, the token saved in the cookies is retrieved, hashed, and verified against the digest stored in the database. This process authenticates the user.

rails console --sandbox
user = User.first
user.remember
  TRANSACTION (0.1ms)  SAVEPOINT active_record_1
  User Update (0.3ms)  UPDATE "users" SET "updated_at" = ?, "remember_digest" = ? WHERE "users"."id" = ?  [["updated_at", "2024-05-12 05:18:18.739100"], ["remember_digest", "$2a$12$RQayRzS/lv5Je8NDcycI9ut2uMn8uNDMWUZ.H0t1ixBXyRHFn6mYS"], ["id", 1]]
  TRANSACTION (0.0ms)  RELEASE SAVEPOINT active_record_1
=> true

Conclusion

Through this article, we've explored secure methods of user authentication using tokens and digests, with a focus on SecureRandom for generating safe tokens. Understanding this foundation is crucial for further strengthening security measures.

Thank you for reading! If you liked this article, please give it a "like" 🎉.

【Self-Introduction】I'm new to "Dev.To" 📚

Takehiro_Yamazaki — Sat, 04 May 2024 08:10:47 +0000

Introduction

Hello, nice to meet you! My name is Take. I work as an software engineer at HR development company in Tokyo,Japan. 🇯🇵

From now on, I plan to write articles on "dev.to" to share what I've learned and discuss my career as an engineer.

My Career

Graduated from a university in Tokyo in March 2022.
Started working as a national government official in April 2022.
Resigned in February 2023.
Currently working(in-house HR development in Tokyo)since March 2023.

Why I started using "dev.to"

There are 3 main reasons.

I want to keep a record of my career, including my daily experiences and learning.
To challenge myself by writing in English.
It's a globally recognized tech platform.

Additionally, I have a preference of the simple UI of "dev.to".

Here's what I'm currently working on:

I work as an software engineer at an in-house development HR company in Tokyo.

Main Tech Stack

Ruby
React
AWS
Terraform
Docker
Datadog

What I'll write about on "dev.to"

Here are some of the themes I plan to tackle on "dev.to".

Sharing what I learn about engineering.
Discussions on career development.
Everyday life in Tokyo

I'll casually share things I've actually experienced myself.

Thank you for your continued support!

I'll strive to keep my posts short and clear. Please continue to follow and enjoy my updates.

That's all.

DEV Community: Takehiro_Yamazaki

Rails Meets GraphQL: How to Master context and find_by with Examples

Introduce

🔍 What’s the Deal with context and find_by?

🕵️‍♂️ find_by: The Database Detective

🤝 context: The Request Sidekick

✅ When context Saves the Day

Example: Fetching a User Profile

🔎 When find_by Takes the Lead

Example: Finding a Post by ID

🧠 Your Cheat Sheet for Choosing

💭 My Two Cents from the Trenches

🔄 Why I Reach for context

🔍 Why find_by Still Has Its Place

🚀 Wrapping Up: Your Action Plan

📚 Further Reading

【Docker & Rails】How to Securely Modify Database Migrations 🐳

How to Safely Update Rails Migrations in a Docker Environment

Initial Table Structure

Recommended Approach (Creating a New Migration)

Step 1: Generate a new migration file in Docker

Step 2: Edit the migration file

Step 3: Run the migration in Docker

Important Notes

Summary

References

How to Toggle Auto-Completion in Cursor Editor 🎉

Background

Prerequisite

Steps to Disable Auto-Completion

Before

After

How to Re-Enable Auto-Completion

Reference

🎨 CI/CD Workflow with AWS and Docker

Introduction

Key Technologies Used

Overall Process (tool:Excalidraw)

Detailed Explanation by Part

From Code Push to GitHub Actions

From GitHub Actions to AWS ECR

From AWS ECR to ECS

From ECS to Application Deployment

Conclusion

💎 Using Ruby's SecureRandom to Strengthen User Authentication

Introduction

Background

What is SecureRandom?

What is a Token?

What is a Digest?

Comparing Tokens and Digests

Generating a Token

Generating a Digest

User Authentication Process

Conclusion

【Self-Introduction】I'm new to "Dev.To" 📚

Introduction

My Career

Why I started using "dev.to"

Here's what I'm currently working on:

Main Tech Stack

What I'll write about on "dev.to"

Thank you for your continued support!

🔍 What’s the Deal with `context` and `find_by`?

🕵️‍♂️ `find_by`: The Database Detective

🤝 `context`: The Request Sidekick

✅ When `context` Saves the Day

🔎 When `find_by` Takes the Lead

🔄 Why I Reach for `context`

🔍 Why `find_by` Still Has Its Place