DEV Community: Humberto Arroyo

How to Create a GraphQL API With Ruby on Rails: A Step-by-Step Guide - Part 1

Humberto Arroyo — Tue, 16 Jan 2024 22:59:25 +0000

In the ever-evolving world of Ruby on Rails web development, the adoption of GraphQL has taken a leading role due to its flexibility and efficiency in creating APIs. In this article, I'll walk you through a step-by-step approach to integrating GraphQL into a Rails project focused on articles and comments. From initial setup to creating specific queries and resolvers, we'll explore together how to leverage the power of GraphQL in our application.

Creating the Rails Application and Configuring GraphQL

Before we dive into the fascinating world of GraphQL, make sure you have your development environment up and running.

Let's start by creating a new Rails application and configuring GraphQL. Let's run the following commands to start our project:

rails new articles-graphql-app
cd articles-graphql-app
bundle add graphql

This set of commands sets the basics for integrating GraphQL into our application:

rails new articles-graphql-app: This command creates a new Rails application named "articles-graphql-app".
cd articles-graphql-app: This command changes the current working directory to the newly created "articles-graphql-app" directory. Move inside the project folder to perform specific actions in that context.
bundle add graphql: Adds the graphql gem to your project's Gemfile. The graphql gem provides the necessary tools to implement GraphQL in your Rails application.

Now let's run the rails generate graphql:install command in the root of the project which sets up the basic infrastructure for GraphQL in your Rails application. It organizes your GraphQL code into specific folders, making it easier to manage and scale as you add more functionality to your GraphQL API, generating the following points:

Route for GraphQL that adds a new route in your config/routes.rb file that maps the /graphql URL to the generated GraphQL driver. This route acts as the entry point for GraphQL requests.
Controller named GraphqlController in the app/controllers directory. This controller is responsible for handling GraphQL requests and orchestrating the execution of queries and mutations.
Folder app/graphql in which all related GraphQL files will be organized. Within app/graphql, specific subfolders are created to organize different components:
- mutations: Here you can define and manage GraphQL mutations that modify data in your application.
- resolvers: In this folder, you can implement resolvers that handle GraphQL queries and mutations. The resolvers are responsible for obtaining and returning the requested data.
- types: Contains the definitions of GraphQL types that represent your models and data structures in the application.

Generating models and data for Post and Comment models

To be able to interact with the models you must generate the models and data. In this case you are going to use a gem called faker. We will run the following command to add the gem to the Gemfile

bundle add faker

Faker is a useful tool to generate dummy data in a realistic way, which will ease the creation of test data for your article and comment models.

Now you are going to generate the model for Post that includes two fields: title of type string and content of type text. This model will represent the articles in the application.

rails generate model Post title:string content:text

Now you are going to generate the Comment model that includes a text content field and establishes a belongs_to association with the Post model. This will allow each comment to be linked to a specific article in our application.

rails generate model Comment post:belongs_to content:text

You must set the reverse relationship in the Post model. Open the app/models/post.rb file and add the line has_many :comments to indicate that an article can have many comments. Your app/models/post.rb file might look something like this:

class Post < ApplicationRecord
  has_many :comments
end

Now let's edit the db/seeds.rb file so that you can create 20 articles, each with a generated fake title and three related comments, each with fictitious content. The script should look like this:

require 'faker'


20.times do
  post = Post.create(
    title: Faker::Lorem.sentence
  )
  3.times do
    Comment.create(
      post: post,
      content: Faker::Lorem.paragraph
    )
  end

end

puts 'Seed data created successfully!'

To run the seed script, simply place this code in the db/seeds.rb file. Then, you can run the following commands to ensure that all the data has been created as expected:

rails db:migrate
rails db:seed

Ready to move on to the next steps? 🚀

Setting Resolvers for Posts

Basically a resolver is a function that handles the logic to obtain the data requested by a GraphQL query or mutation. In other words, a resolver answers the question "how to get this specific data?".

Now let's set up resolvers and GraphQL types to handle specific queries. Add this line to app/graphql/types/query_type.rb:

field :posts, resolver: Resolvers::PostsResolver

To display the file app/graphql/types/query_type.rb like this:

module Types
  class QueryType < Types::BaseObject
    description "The query root of this schema"

    field :posts, resolver: Resolvers::PostsResolver
  end
end

By adding the :posts field to your GraphQL query type (QueryType) and associating it with the Resolvers::PostsResolver, you are configuring GraphQL to handle posts queries. This resolver will take care of getting and returning the necessary information when a posts query is performed.

Now we're going to create the resolver to get all the posts in app/graphql/resolvers/posts_resolver.rb:

module Resolvers
  class PostsResolver < BaseResolver
    type [Types::PostType], null: false

    def resolve
      ::Post.all
    end
  end
end

Setting Types for Posts and Comments

To give some context, a Type refers to the data structure that you can query or modify using the GraphQL query language. In GraphQL, types represent the entities in our system and define the fields that can be queried or mutated on those entities.

Now let's define the post type in app/graphql/types/post_type.rb:

class Types::PostType < Types::BaseObject
  field :id, ID, null: false
  field :title, String, null: false
  field :content, String, null: false
  field :comments, [Types::CommentType],
      description: "This post's comments, or null if this post has comments disabled."
end

By creating the PostType type in app/graphql/types/post_type.rb, you are defining how it will be structured and what fields will be available when information about a post is requested through GraphQL. This PostType type includes fields such as id, title, and content, and also provides a comments field that represents the comments associated with that post.

With the post type definition in place, your GraphQL schema now has a clear representation of how posts are structured and their relationships to other types.

Now let's define the comment type in app/graphql/types/comment_type.rb:

class Types::CommentType < Types::BaseObject
  field :id, ID, null: false
  field :post, Types::PostType, null: false
  field :content, String, null: false
end

In this CommentType type, you are specifying that a comment has fields such as id, post, and content. The post field represents the relationship between a comment and the post it belongs to, using the PostType type you defined earlier.

With the comment type definition in place, you now have a more complete GraphQL schema that clearly represents the structure of your data

Testing the Posts API

After setting up our GraphQL API for Posts, execute your rails server and now you can test it using cURL directly from the command line or with more visual tools like Postman:

curl --location 'http://localhost:3001/graphql' \
--header 'Content-Type: application/json' \
--data '{"query":"query {\n  posts {\n    id\n    title\n    comments {\n        id\n        content\n    }\n  }\n}\n","variables":{}}'

In Postman, for example, the result should look like this:

In this journey through implementing GraphQL in a Ruby on Rails application, we've covered everything from initial setup to creating GraphQL resolvers and types to handle specific queries. GraphQL gives us the flexibility to request exactly the data we need, resulting in more efficient and tailored APIs.

We've explored creating types, resolvers and how to test our queries using cURL and Postman. Now with a solid foundation, but in the next post we will add to our schema GraphQL includes an additional query called post, which uses the Resolvers::PostResolver resolver to handle retrieving a specific post by its id.

PGP - Encrypt/Decrypt file with Ruby on Rails (Part 3)

Humberto Arroyo — Thu, 29 Sep 2022 14:23:01 +0000

In the previous two posts we have seen:

In this tutorial we are going to explain how to encrypt and decrypt in Ruby on Rails with the GPGME gem.

Summary

GPGME provides an encryption, decryption, signing, signature verification and key management
Encrypt data with GPGME gem
Decrypt data with GPGME gem

Ruby gem GPGME (GnuPG Made Easy) is a library designed to make access to GnuPG easier for applications. GPGME provides a High-Level Crypto API for encryption, decryption, signing, signature verification and key management.

Encrypt data with GPGME gem

Must be have an imported recipient's public key.

crypto = GPGME::Crypto.new
GPGME::Key.import(File.open('recipient_public_key.pgp'))

Read file or data to encrypt

plaintext = GPGME::Data.new(File.open('file.csv'))

#Our file contains following data:
#last_name, name, mobile_phone\nSmith,Chris,3336985726

Encrypt data with following options
- Recipients: For which recipient do you want to encrypt this file.
- Sign: Must be true, performs a combined sign and encrypt operation.
- Signers: Sender of encrypt file.

options = { sign: true, signers: 'sender@foo.com', recipients: 'recipient@foo.com' }
data = crypto.encrypt plaintext, options

Create and save encrypted file in gpg extension:

f = File.open('encrypted_file.gpg', 'wb')
bytes_written = f.write(data)
f.close

Now we have a file with this name encrypted_file.gpg and we can send to the recipient into S3, SFTP, etc.

Decrypt data with GPGME gem

Must be have an imported recipient's private key.

crypto = GPGME::Crypto.new
GPGME::Key.import(File.open('recipient_private_key.pgp'))

Read and create Data instance of encrypted file

cipthertext = GPGME::Data.new(File.open('encrypted_file.gpg'))

Decrypt data and print

data = crypto.decrypt cipthertext, {}
puts data
#last_name, name, mobile_phone\nSmith,Chris,3336985726

PGP - Create a Public/Private Key Pair(Part 2)

Humberto Arroyo — Thu, 29 Sep 2022 14:19:30 +0000

As we mention in the previous post PGP is a popular solution for encrypting, decrypting, signing, and verifying messages and files, often found in email communications and package repository identity verification (because security matters).

In this post we'are gonna create Public/Private key pair to to encrypt and decrypt data.

Summary

Private key is a secret key that allows you to decrypt the messages.
Public key encrypts data for a specific receiver.
Install gnupg.
Generate Public/Private key pair.

Secret key cryptography is effective for communication over insecure channels as the piece of information or parameter used helps the information to encrypt and decrypt messages.

Private key is a secret key that allows you to decrypt the messages sent to you based on a public key. The private key can also be used to generate message and file signatures.

Public key converts to encrypt data and it's uses asymmetric algorithms. A person who has a public key can encrypt the message intended for a specific receiver. The receiver with the private key can only decode the message, which is encrypted by the public key. The public key is free to use.

If Ana and John want to exchange a secret message, Ana (the sender) will encrypt the message using John's (the recipient) public key. When John receives the message, he will decrypt the message with his private key. No other parties can decrypt the message unless they have John's private key.

How we can create GPG key pair keys?

Install gnupg as our GPG client

brew install gnupg

Generate a GPG key pair

gpg --full-generate-key

At the prompt, specify the RSA(Rivest-Shamir-Adleman) key(option 1) and press Enter.
At the prompt, specify the key size you want, or press Enter to accept the default.
Enter the length of time the key should be valid. Press Enter to specify the default selection.
Enter your user ID information.
Paste the text below, substituting in the GPG key ID you'd like to use. In this example, the GPG key ID
Get Private key, signer(sender of encrypt file) should be an email example: foo@foo.com

gpg --output private_key.pgp --armor --export-secret-key foo@foo.com

Get Public key:

gpg --output public_key.pgp --armor --export foo@foo.com

Optional: You can encode in base64 your key pherhaps to save in local environment. Run following command to get the private key encoded in base64

base64 private_key.pgp
//Output example: LS0tLS1CRUdJTiBQR1AgUFJJVkFURSBLRVkgQkxPQ0stLS0tLQoKbFFjWUJHTWphV0VC...

PGP - Introduction Encryption and Decryption (Part 1)

Humberto Arroyo — Thu, 29 Sep 2022 14:17:43 +0000

Summary

Encryption converts plaintext into ciphertext.
PGP is used for signing, encrypting, and decrypting information.
Decryption converts encrypted data into original form.

In cryptography, encryption is the process of encoding information. This process converts the original representation of the information(plaintext) into an alternative form known as ciphertext.

Decryption is the conversion of encrypted data into original form. It is generally a reverse process of encryption.

Pretty Good Privacy (PGP) is an encryption program that provides cryptographic privacy and authentication for data communication. PGP is used for signing, encrypting, and decrypting data(texts, e-mails, files, directories, and whole disk partitions and to increase the security of e-mail communications) and allow us send and receive files securely.

PGP and similar software follow the OpenPGP, an open standard of PGP encryption software, standard (RFC 4880) for encrypting and decrypting data.

Use case

Ana and John are two people that want to exchange messages

Ana wants to send a private message
John generates a public and a private key
John keeps the private key and send back to Ana his public key
Ana encrypts her message using John's public key
Ana sends to John the encrypted message
John decrypts the encrypted message with his private key

Important: If John(recipient) wants to receive encrypted message, it must generate key pair.

Antecedentes y razones para aprender JavaScript

Humberto Arroyo — Tue, 06 Sep 2022 02:37:20 +0000

Mocha es un lenguaje creado en 1995 por Brendan Eich, un programador de Netscape. Más tarde Mocha se convertiría JavaScript y fue creado para hacer pequeñas animaciones, interacciones a usuarios y otro tipo de situaciones para la web.

Hoy, años después, el 98% de sitios web en internet usan JavaScript. Todo aquel que desea hacer una carrera en desarrollo web debe aprender JavaScript.

A continuación te diré algunas razones para aprender JavaScript.

Es el lenguaje de programación más popular

Como mencioné anteriormente, JavaScript está en la mayoría de sitios web dentro de internet. Además, Stack Overflow lanza una encuesta anualmente donde JavaScript se coloca como el lenguaje más popular por décimo año consecutivo.

Es el lenguaje por default del internet

JavaScript es el lenguaje por default del internet y nativo de los navegadores, por lo cuál, no es necesario un IDE para programar en JavaScript. Si usted tiene acceso a un navegador web y a algún editor de texto, está configurado para probar su código dentro del navegador.

Amigable para principiantes

La sintaxis de este lenguaje es más fácil comparado con otros lenguajes de programación. Además, tiene miles de recursos gratuitos y una gran comunidad que hace una excelente oportunidad para principiantes.

Lenguaje versátil

Con JavaScript puedes aprender tanto Front-End como Back-End para el desarrollo web, lo que significa que no es necesario de otro lenguaje para crear sitios web completos.

Desarrollo web no es el único campo de desarrollo de JavaScript, se pueden crear desktop apps con Electron o mobile apps con React native, los cuáles, son frameworks de JavaScript.

Por otro lado, también se pueden crear apps para smartwatch, video juegos, VR(realidad virtual), AR(Realidad aumentada), etc.

Alta demanda

Hoy en día con todo lo que la internet está expandiendo, provoca que haya una gran demanda de desarrolladores e incluso con muchas posiciones remotas y con salarios competitivos lo cuál lo hace interesante. Como lo mencioné anteriormente, JavaScript es el lenguaje más usado por décimo año consecutivo con un 65% y no veo como pueda ser remplazado.

Una gran comunidad

Las comunidades juegan un gran papel dentro del aprendizaje, ya que los principales obstáculos que pueda usted enfrentar como principiante seguramente ya están resueltos.

JavaScript tiene una gran comunidad en los sitios como Stack Overflow, GitHub, Reddit, Twitter, Slack, Discord, etc.

Orientado al futuro

La gran cantidad de usuarios qué hay en internet día con día, hace que se necesiten de más desarrolladores para satisfacer las necesidades del mercado. Incluso, el lenguaje ha evolucionando cada año que hoy en día se implementa para tecnologías como VR, AR, inteligencia artificial, entre otros; ésto abre un camino inmenso de posibilidades hacia el futuro.