DEV Community: Bryan Oyloe

Destructuring Deeply Nested Objects and Arrays with ES6

Bryan Oyloe — Mon, 25 Jan 2021 22:12:04 +0000

Intro

I was working on a project that was receiving data from an external API that I wanted to use for an app. The data coming from the API was exactly what I needed but the way that it was being returned was difficult to work with. It was returning an object of objects of arrays of objects and the data that I needed was buried down several levels. I knew that it was possible to destructure an object or an array at one level but I was unaware that it could be used to dig down deep into a nested structure. Thanks to Paige Niedringhaus for her article Using ES6 To Destructure Deeply Nested Objects in JavaScript & Avoid Undefined Errors that Break Your Code that showed me how this can be done.

Issue: My Data

nlmSearchResult: {
    term: ["Sinusitis"]
    file: ["viv_j2Dfzc"]
    server: ["pvlb7srch16"]
    count: ["11"]
    retstart: ["0"]
    retmax: ["1"]  
    list: [
        {
        document: [
            {
            content: []//Array of data that I want,
            },
        ],
        },
    ];
}

This is the structure of the data that was being returned from my API call. The data that I needed was located inside of an array that was buried down deep as the value for content key. There was all this extra information that I didn't really need. At first I thought I could just chain together a bunch of object calls to get what I wanted but I think that chaining tends to get a little messy so I looked into nested destructuring and found that it was possible and super easy. I just had to set it up like a normal destructuring but continue further down like so.

const {
  nlmSearchResult: {
    list: [
      {
        document: [{ content }],
      },
    ],
  },
} = resultFromApiCall

This code was destructuring the resultFromApiCall and giving me the data I wanted, now assigned to the constant content.

console.log(content) //Data that I needed to display in my app

Now I could take that data and manipulate it however I wanted and not have to carry around all of that extraneous info that was in the api response. Super Cool.

Thank you for reading. If you have any questions about this article or anything JavaScript or TypeScript related, please shoot me a message. I always love to talk tech.

Creating a New Gatsby Project with Gatsby Default Starter Page

Bryan Oyloe — Mon, 18 Jan 2021 18:08:41 +0000

Intro

I recently started working a little bit with the Gatsby framework for my React projects and have loved it. It is minimal, easy to use, and can be very flexible through its library of different plugins. We are going to make a very basic home page for our Gatsby site using the default Gatsby Starter project and add a little styling with javascript.

Getting Started

First things first, we need to get the Gatsby project up and running. If this is your first time using Gatsby then you will need to install Gatsby-cli by running

npm install -g gatsby-cli

You must have Node v10+ installed already on your machine for this to work. We are going to be using a bare-bones Gatsby starter for our project. In the terminal, type

gatsby new my-gatsby-project https://github.com/gatsbyjs/gatsby-starter-default

This will begin building the Gatsby default starter project for us to work with. Once it is finished building, cd into the project directory and open up the project in your text editor of choice.
We can clean up the project to remove some of default code that we won't be needing. We can delete the gatsby-browser.js, gatsby-node.js, and gatsby-ssr.js files from the root directory since we won't be using them. You can also open up the src/index.js and delete everything that is between the layout components so that your new index.js will look like this.

import React from "react"
import Layout from "../components/layout"


const IndexPage = () => (
  <Layout>

  </Layout>
)

export default IndexPage

The default starter is nice because it comes pre-loaded with a header and layout component that we can use to build out a pretty easy landing page. Navigate to the gatsby-config.js file and take a look. This is a basic configuration for your page. Under plugins, the first line should read

gatsby-plugin-react-helmet

This plugin allows you to provide meta data for your site such as title, description and more. Under siteMetaData at the top, go ahead and change the title and description values to what you want your site title/description to be.

title: `Gatsby.js is the Coolest`,
    description: `Kick off your next, great Gatsby project with this default starter. This barebones starter ships with the main Gatsby configuration files you might need.`

If you want to know more about the other plugins you can checkout the Gatsby Plugin Docs for more info.

Go ahead and start up the development server by typing
in the terminal

gatsby develop

Gatsby is now hosting the development version of the project on localhost:8000 so open up your browser and put that in the url window. You should see the default page pop up with your new title in the purple header. This purple header comes as the default with this starter template. If you want to change some of the styling on it you can alter the header.js component to your liking.

Think of the index.js page as your home page. This is where anyone navigating to your site will land.

Now let's add some text to our page style it up a bit. Gatsby is a React framework so JSX will work just fine. Inside the <Layout> component in the index.js go ahead and add the following code.

const IndexPage = () => (
  <Layout>
    <h1>Welcome to my Gastby Project Home Page</h1>
    <p>
    Lorem Ipsum is simply dummy text of the printing and typesetting industry. 
    Lorem Ipsum has been the industrys standard dummy text ever since the 1500s, 
    when an unknown printer took a galley of type and scrambled it to make a type specimen book. 
    It has survived not only five centuries, but also the leap into electronic typesetting, 
    remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset 
    sheets containing Lorem Ipsum passages, and more recently with desktop publishing software 
    like Aldus PageMaker including versions of Lorem Ipsum.
    </p>    
  </Layout>
)

Now we have a heading and some text that we can play around with. Styling can be done using traditional css if you like or you can use css in javascript through the style attribute directly on the JSX tags.

const IndexPage = () => (
  <Layout>
    <h1 style={{fontSize: 72, color: "blue", textDecoration: "underline"}}>Welcome to my Gastby Project Home Page</h1>
    <p style={{fontStyle: "italic"}}>
    Lorem Ipsum is simply dummy text of the printing and typesetting industry. 
    Lorem Ipsum has been the industrys standard dummy text ever since the 1500s, 
    when an unknown printer took a galley of type and scrambled it to make a type specimen book. 
    It has survived not only five centuries, but also the leap into electronic typesetting, 
    remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset 
    sheets containing Lorem Ipsum passages, and more recently with desktop publishing software 
    like Aldus PageMaker including versions of Lorem Ipsum.
    </p>    
  </Layout>
)

Applying the styling gives us this new look

Play around with adding different JSX elements and styling them to create an awesome home page. This is only the beginning of what you can do with Gatsby. Coming soon I will dive into creating multiple pages within your app and how to handle routing between them. Stay Tuned.

Creating an Express server with Node.js Part 3: Setting up Relationships Between Tables

Bryan Oyloe — Tue, 10 Nov 2020 14:52:57 +0000

So far in the series we have set up our Express app and built a table to store our 'owners' in our database with Knex. If you have been following along, our app now has a table of 3 pet owners, each has a name and a unique id. In this article I am going to show you how to create a table that will contain pets that belong to the owners. Each pet will have a name, age, and a species attribute assigned to them. We will also be giving each pet a unique id. This will all be familiar as it is exactly what we did with our owners. The difference is going to be in how we relate each pet to a specific owner in our database.

First Steps

If you are just starting this series from here, you will need to go back to part 1 and work through the previous installments to get your project up to speed. Open up your terminal and navigate into your project directory, then open your project in your text editor. We currently have a few owners but they are lonely, so we need to give them some pets.

Creating our Pets

Like we did in the previous post with our owners table, we are going to create a migration for our pets table and then seed some data for it. First we need to create the migration. In the terminal type

npx knex migrate:make create-pets-table

Navigate into our newly created migration file. We want to define our exports.up function to create the pets table. For this exercise, we want each of our pets to have a string for their name and for their species. We also want to give our pets an age attribute that will be an integer. Also, like we did with our owners table, we want Knex to give each pet a unique id. Copy this code into your new pets migration

exports.up = function(knex) {
    return knex.schema.createTable('pets', table => {
        table.increments('id');
        table.string('name');
        table.string('species');
        table.integer('age');


    })
};

exports.down = function(knex) {
    return knex.schema.dropTableIfExists('pets');
};

We also define our exports.down function in case we need to rollback our migration. Remember, if you don't define both up and down, Knex will throw an error message.

This looks very similar to the work we have already done. This is good but it doesn't give us a way of assigning each pet we create to a specific owner. To do that we need to create a reference on every pet. This is done like so

exports.up = function(knex) {
    return knex.schema.createTable('pets', table => {
        table.increments('id');
        table.string('name');
        table.string('species');
        table.integer('age');        
        table.integer('owner_id')
          .references('id')
          .inTable('owners')

    })
};

exports.down = function(knex) {
    return knex.schema.dropTableIfExists('pets');
};

Looking at the new line in our exports.up function, this actually reads pretty easily. Knex is going to create an integer column for our pets table called 'owner_id'. This column will be a reference to the 'id' column in the 'owners' table. Every time we create a new pet, we will now also have to specify which owner it belongs to. This is how we will map our relationships. Go ahead and run your new migration.

npx knex migrate:latest

Seeding our pets

We are going to be using the same seed file that we created for our owners but making some changes to it so that we can create our pets too. When creating tables that contain references, we have to remember to always make sure that the table we are referencing actually exists or we are going to get errors. In other words, we can't create a pets table if the owners table doesn't exist or more specifically, we can't give a pet to an owner that doesn't exist. So we will always have to make sure that our owners get created before the pets. Our new seed file will look like this

exports.seed = async function(knex) {
  await knex('pets').del()
  await knex('owners').del()

  const bryan = await knex('owners').insert([
    {
      name: 'Bryan'
    }
  ])
  const shelly = await knex('owners').insert([
    {
      name: 'Shelly'
    }
  ])
  const catalina = await knex('owners').insert([
    {
      name: 'Catalina'
    }
  ])

  await knex('pets').insert([
    {
      name: 'Fluffy',
      species: 'Dog',
      age: 4,
      owner_id: bryan
    },
    {
      name: 'Spot',
      species: 'Dog',
      age: 12,
      owner_id: bryan
    },
    {
      name: 'Mittens',
      species: 'Cat',
      age: 2,
      owner_id: shelly
    },
    {
      name: 'Bandit',
      species: 'Cat',
      age: 4,
      owner_id: catalina
    },
    {
      name: 'Rufus',
      species: 'Dog',
      age: 8,
      owner_id: catalina
    },

  ])
}

Just like before we will be using async/await to control the flow of our program. Remember we don't want to create any pets until we have created owners for them. Async/await gives us that control. Notice that we set each of the owners to a variable so we can reference them when creating our pets. If we were to statically enter the current id for the owner (i.e. typing 1 instead of bryan) it will work the first time we seed. However, if we ever go back and re-seed, the id for "Bryan" will be re-incremented by Knex and we will get an error since owner_id: 1 will no longer exist. Feel free to change the names and species to whatever you want, it will not affect the program as long as you make them strings. Let's run our seed file.

npx knex seed:run

Now we can check out the database to make sure that we have created all of our new pets.

sqlite3 dev.sqlite3

sqlite> .headers on
sqlite> .mode column
sqlite> SELECT * FROM pets;
id          name        species     age         owner_id  
----------  ----------  ----------  ----------  ----------
11          Fluffy      Dog         4           16        
12          Spot        Dog         12          16        
13          Mittens     Cat         2           17        
14          Bandit      Cat         4           18        
15          Rufus       Dog         8           18

As you can see, we now have 3 new dogs and 2 new cats. Each pet is tied to a specific owner through the owner_id column. Your id and owner_id numbers may be different depending how many times you run your seed file. Remember, every time the seed file runs, it deletes all previous entries and re-inserts them with a newly incremented id.

Conclusion

Congrats, you now have a database containing tables for your pets, and for their owners. In the final part of the series we are going to use the Objection package to bring it all together so that we can access our data easily in a format that we can use in building out a website.

Creating a Backend Server using Node Part 2, Adding Knex

Bryan Oyloe — Mon, 09 Nov 2020 15:28:31 +0000

In the last part of this series I walked through how to get a Node Express server running and have it return a text response to an HTTP GET request. In this article, I will show you how to add Knex to your project so that you can create migrations to your database and create seed data.

First Steps

Starting with the "Hello World" project that we set up before in part 1 we want to add a database to our project as well as the Knex package. We are going to be using sqlite3 as our database because it is lightweight and easy to work with for development. In your terminal type

npm i sqlite3 knex

Now that we have installed our database and knex package we can get to work. First we need to create our knex file. Run this command to generate knexfile.js:

npx knex init

This will create a new JavaScript file that looks like this

// Update with your config settings.

module.exports = {

  development: {
    client: 'sqlite3',
    connection: {
      filename: './dev.sqlite3'
    }
  },

  staging: {
    client: 'postgresql',
    connection: {
      database: 'my_db',
      user:     'username',
      password: 'password'
    },
    pool: {
      min: 2,
      max: 10
    },
    migrations: {
      tableName: 'knex_migrations'
    }
  },

  production: {
    client: 'postgresql',
    connection: {
      database: 'my_db',
      user:     'username',
      password: 'password'
    },
    pool: {
      min: 2,
      max: 10
    },
    migrations: {
      tableName: 'knex_migrations'
    }
  }

};

We can clean this up a little since we won't be using everything in this file. Delete everything except the development object so that your file looks like this

// Update with your config settings.

module.exports = {

  development: {
    client: 'sqlite3',
    connection: {
      filename: './dev.sqlite3'
    }
  },
}

Migrating

Now that we have taken care of that, it is time to start talking to our database. Go ahead and run the following command

npx knex migrate:make create-owners-table

We are going to make a table of owners where each owner will eventually be able to have pets. Now Knex has created a migration folder with a .js file for our new migration that looks like this


exports.up = function(knex) {

};

exports.down = function(knex) {

};

Knex wants us to define the exports up and down functions. The up function controls what happens when we run our migration and the down function controls what happens when we want to roll back the migration. We must define both or we will get an error. We want to give our owners a name attribute and a unique id. Knex gives us an easy method to assign an id. Add this code to your migration file

exports.up = function(knex) {
    return knex.schema.createTable('owners', table => {
        table.increments('id')
        table.string('name')
    }
  )
};

exports.down = function(knex) {
    return knex.schema.dropTableIfExists('owners')
};

In our exports.up we are asking knex to create a table named 'owners'. The table.increments('id') is creating a column on that table called id, and Knex will automatically increment it by one every time a new owner is created so we always have a unique identifier for each owner, even if two owners have the same name. Then Knex is creating another column for the owners name as a string. Finally, in the exports.down we are telling Knex to delete the 'owners' table if it exists. This will be run if we need to rollback our migration.

Now we are ready to run our migrations. In your terminal type

npx knex migrate:latest

Time to make some seed data for our new migration!

Seeds

Our database is no good unless it has some data in it. So let's make some owners to go in our database.

npx knex seed:make 01-create-owners

This command will create a seed folder with a new .js file for us to create seeds. The "01" part of the name is just for tracking purposes if you later on want to create more seed files. In this new file there is some boiler plate code to get started. We are going to throw most of it away and turn this into an async/await function. If you want to learn more about how async/await works there is plenty of documentation available but for this example it is not necessary to understand how it works. Enter the following into your new 01-create-owners.js file


exports.seed = async function(knex) {
  await knex('owners').del()
  await knex('owners').insert([
    {
      name: 'Bryan'
    },
    {
      name: 'Shelly',
    },
    {
      name: 'Catalina'
    }

  ])
}

When our seed file runs, this will first delete all current entries in our owners database and will then insert our seeded owners. You can change the names to whatever strings you want. You don't have specify the 'id' column because Knex will automatically populate that with a unique integer. Our seeds are ready to go. Go ahead and run

npx knex seed:run

Now you have a database that contains a table with your new owners names and their respective id's. If you want to check that our owners now exist you can open the sqlite3 shell

sqlite3 dev.sqlite3

This will access our new database dev.sqlite3 and allow us to search it with SQL commands.

SELECT * FROM owners;

This command will select everything from the owners table and print it to your terminal like so

1|Bryan
2|Shelly
3|Catalina

Voila, we have our 3 owners!

In the next installment of this series, I will walk you through making a pets table and connecting it with our owners table so that we can look at an owner to see what pets they have and look at a pet to see who is their owner. Stay Tuned!

Creating a Express Server using Node Part 1: Hello World

Bryan Oyloe — Mon, 09 Nov 2020 15:19:26 +0000

So you want to build a website but you don't know where to begin when it comes building a backend for your data? Node and Express provide a flexible set of tools to build up your backend. Node is a runtime that allows programmers to write JavaScript outside of the browser. This can be very powerful when it comes to building data servers. In this first post I will be taking you through the "Hello World" setup for your first Node backend.

First Steps

To begin, you will have to install node to your system. You can run this line of code to get nvm installed on your system.

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh | bash
export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"

If you type

command nvm -v

Your terminal should print "nvm" to the screen. Nvm will now allow us to install Node and use npm(Node Project Manager) directly from the terminal. Now we can install Node with the following commands:

nvm install node
nvm use node
nvm alias default node

You are also going to need a text editor. I will be using VSCode but there are many other fine editors.
Now that we have node installed, open your terminal and create a directory for your new project. I have called the project "Part1-HelloWorld" on my machine. After creating, make sure you are in your new folder and type npm init. The npm init command initializes node for your project, and will ask a series of questions on how you want to format your node packages for this project. If you want to accept all defaults you can use the -y flag like so.   Your terminal should look like this:

Part1-HelloWorld npm init -y
Wrote to /Users/bryanoyloe/Flatiron/Mod5/BlogPosts/NodeExpress/Part1-HelloWorld/package.json:

{
  "name": "Part1-HelloWorld",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}


➜  Part1-HelloWorld

The purpose of the package.json is to store the dependencies, scripts, and metadata for your project. The packages we are going to install will be placed in a node_modules file which contains the actual code these packages use to run.

Installing Packages

The next step is to install the packages we are going to need to get up and running. Since we are just going to be doing a simple "Hello World", our package needs are minimal. In your terminal type

npm install express

then

touch index.js

The index.js file will be our main file for spinning up our server. Open your project folder up in your text editor and navigate to your index.js. In the index.js file type the following:

const express = require('express')
const app = express()

app.listen(4000)

Here we are requiring the express package from our node modules and creating an instance of express, assigning it to a const app. App is an arbitrary name and we could call it anything we want, however using the constant app follows convention. Finally we are telling our app instance to listen for HTTP requests on port 4000. This is going to allow us to make requests to our server, and get information from our server. Now we are ready for our "Hello World" moment. We need to write some code that tells our server how to respond to requests that we make. First, we will be creating an action that responds to a GET request from a web browser. Insert this code into your index.js file.

app.get('/', (request, response) => {
    response.send("Hello World")
})

This code is handling a GET request to the '/' or 'Home' path. The first argument is the path that we want the action to handle, and the second is a callback function that takes in the request and response as arguments. Our callback function is simply telling our action to send the string "Hello World" with the response. In your terminal type

node index.js

and open up your internet browser. Navigate to http://localhost:4000 and you should see the "Hello World" response from your server!

That's it for the first installment of this series on Node. In the next part I will be discussing how to begin talking to a database so that you can persist information and pull it from the database as needed. Stay Tuned.

How-To: Using the Faker Gem to Seed your Rails Database

Bryan Oyloe — Tue, 08 Sep 2020 23:15:31 +0000

Introduction

Faker is a ruby gem that gives you random data in many different categories that can easily generate database seeds for use in your rails applications. Say you are building an app that tracks the Pokemon that a trainer has captured. In order to test your database, you would need to seed it with some Pokemon and trainers. Using Faker gem you can generate random trainers with names and ages, as well as randomly produce the Pokemon that will seed your database using the names and attributes of the actual Pokemon from the game. No need to program each one in yourself!

How to Use

Installation

Installation of the faker gem is very straightforward. The Faker README is very detailed and provides a great deal of information. To install the faker gem simply type gem install faker in your terminal. After the gem installation is complete, open your rails app and go to your seeds file to begin using Faker. How you utilize the gem depends on the type of data you will be looking for. The README lists all of the different classes that Faker supports, such as Name, Address, Artist etc.
If you prefer to display the list of methods straight from your terminal, there is another gem called faker-bot that can be installed. This guide can walk you through the install process easily.

Application

I started using the Faker gem during a weekend "build and burn" Rails app session with 3 of my class mates at Flatiron School. We were practicing making a one:many relationship and had decided on a players to sports teams model. Here is how our database was set up:

ActiveRecord::Schema.define(version: 2020_08_30_213624) do

  create_table "players", force: :cascade do |t|
    t.string "name"
    t.integer "number"
    t.integer "team_id", null: false
    t.datetime "created_at", precision: 6, null: false
    t.datetime "updated_at", precision: 6, null: false
    t.index ["team_id"], name: "index_players_on_team_id"
  end

  create_table "teams", force: :cascade do |t|
    t.string "name"
    t.datetime "created_at", precision: 6, null: false
    t.datetime "updated_at", precision: 6, null: false
  end

  add_foreign_key "players", "teams"
end

Rather than tediously typing out a bunch of different player's names and numbers, creating a bunch of team's names to assign to the players , I used the Faker gem to do the work for us. Faker::Sports::Basketball allowed us to automatically populate our seed data like so:

Player.destroy_all
Team.destroy_all

5.times do 
    Team.create(name:Faker::Sports::Basketball.team)
end

teams = Team.all 

10.times do 
    Player.create(name: Faker::Sports::Basketball.player, 
                  number: rand(1..99),  
                  team: teams[rand(0..4)])
end

In the Team.create we used the Basketball.team method to randomly generate an actual NBA team using data from Faker. We then populated the array teams by calling Team.all.

Once the teams were created, we used Basketball.player to generate a random, actual NBA player's name. We then randomly assign them a jersey number, and a team by calling team:teams[rand(0..4)]. After running rails db:seed we get a teams table that looks like this:

[#<Team:0x00007fef603eaf88
  id: 12,
  name: "Chicago Bulls",
  created_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00,
  updated_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00>,
 #<Team:0x00007fef5ca7aa28
  id: 13,
  name: "Golden State Warriors",
  created_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00,
  updated_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00>,
 #<Team:0x00007fef5ca7a0f0
  id: 14,
  name: "Toronto Raptors",
  created_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00,
  updated_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00>,
 #<Team:0x00007fef5ca79fb0
  id: 15,
  name: "Memphis Grizzlies",
  created_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00,
  updated_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00>,
 #<Team:0x00007fef5ca79cb8
  id: 16,
  name: "Los Angeles Clippers",
  created_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00,
  updated_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00>]

and we get a players table with this data:

[#<Player:0x00007fef604c3748
  id: 12,
  name: "Kevin Durant",
  number: 99,
  team_id: 16,
  created_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00,
  updated_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00>,
#<Player:0x00007fef60501d68
  id: 13,
  name: "Stephen Curry",
  number: 14,
  team_id: 13,
  created_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00,
  updated_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00>,
 #<Player:0x00007fef60501c78
  id: 14,
  name: "Kyrie Irving",
  number: 41,
  team_id: 13,
  created_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00,
  updated_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00>,
 #<Player:0x00007fef60501bb0
  id: 15,
  name: "LeBron James",
  number: 26,
  team_id: 12,
  created_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00,
  updated_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00>,
 #<Player:0x00007fef60501a70
  id: 16,
  name: "Anthony Davis",
  number: 76,
  team_id: 12,
  created_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00,
  updated_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00>,
 #<Player:0x00007fef60501908
  id: 17,
  name: "Nikola Jokić",
  number: 35,
  team_id: 15,
  created_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00,
  updated_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00>,
 #<Player:0x00007fef605017f0
  id: 18,
  name: "Kyle Lowry",
  number: 92,
  team_id: 16,
  created_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00,
  updated_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00>,
 #<Player:0x00007fef60501700
  id: 19,
  name: "Dirk Nowitzki",
  number: 31,
  team_id: 16,
  created_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00,
  updated_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00>,
 #<Player:0x00007fef60501638
  id: 20,
  name: "Russell Westbrook",
  number: 84,
  team_id: 14,
  created_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00,
  updated_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00>,
 #<Player:0x00007fef605014a8
  id: 21,
  name: "Karl-Anthony Towns",
  number: 83,
  team_id: 15,
  created_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00,
  updated_at: Fri, 04 Sep 2020 22:30:41 UTC +00:00>]

Using this method, we were able to generate 5 teams and 10 players assigned to those teams in a few simple lines of code, instead of typing out each team and player by hand.

Conclusion

One caveat to be aware of, the Faker gem generates random data but doesn't guarantee uniqueness. If your data seeds require uniqueness, check this out for more direction.

Faker is a cool and fast way to generate bulk data quickly for your Rails app seeds. Hope this helped you learn more about it. Thank you for reading.