DEV Community: Graham Vasquez

How to setup GitHub Actions on your Github repository

Graham Vasquez — Mon, 09 Nov 2020 19:14:10 +0000

Writing software is pretty fun, but there are lots of menial tasks that can get annoying. Things like testing, handling deployments, and other small tasks can take away from the fun of writing code. That's why you should automate those tasks!

But what are Github Actions?

Github Actions is the built in automation feature on Github. There are other third-party solutions such as CirclCi and TravisCi which follow the same general idea.

To start with Github Actions, you first need a Github repository! In this tutorial we are going to be working with my existing project, AsyncAirtable, If you want to know more, check out my write up.

Making interacting with the Airtable API even easier

Graham Vasquez ・ Nov 1 '20

#javascript #npm #node #database

Alright, well how do I set them up?

Directory structure

So to get started with github actions you need to create a .github folder in your repository. Within that folder you want to create a workflows folder. So your repo file structure should look like this:

repo/
├── .github/
│   └── workflows
└── ...code

Cool, so now that we have the folder setup, lets take a look at our workflow files.

Workflow yaml files

Github Action workflow files are written in yaml, which is a super easy to read and write. So let's take a look at a workflow yaml file and then break it down!

name: Tests

on:
  push:
    branches:
      - develop
  pull_request:
    branches:
      - master

jobs:
  test:
    strategy:
      max-parallel: 1
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]

    runs-on: ${{ matrix.os }}

    steps:
      - uses: actions/checkout@v2
      - name: Setup Node
        uses: actions/setup-node@v1
        with:
          node-version: 12
      - name: Install
        run: npm install
      - name: Run tests
        run: npm test
        env:
          AIRTABLE_KEY: ${{secrets.AIRTABLE_KEY}}
          AIRTABLE_BASE: ${{secrets.AIRTABLE_BASE}}
          AIRTABLE_TABLE: 'tests'
          TEST_FILTER: "{email} = 'same@test.com'"
          NEW_RECORD: '{"title": "test-create", "value": 23, "email": "new@test.com"}'
          UPDATE_RECORD: '{"title": "test-UPDATED"}'
          DESTRUCTIVE_UPDATE_RECORD: '{"title": "test-UPDATED-destructive", "value": 23}'
          RETRY_TIMEOUT: 60000
          REQ_COUNT: 100

Let's break this down!

name
- The name field is just used to name the workflow on Github.
on
- The on field is used to express when you want this workflow to run.
- In this case I have it running every time code is pushed to my develop branch, or a pull request is created on my master branch.
jobs
- The jobs field specifies the jobs you want to run in the workflow.
- The jobs are listed by name. In this case, my job is called test.
job
- For each job you need to specify some information. This information includes:
- runs-on
  - The operating system the job runs on.
  - In this case I specified a matrix that is an array of operating systems to test my code on all 3 major operating systems. I also make it so only one job can be run at a time using the max-parallel field. (This is due to a constraint with the API I'm talking to 😅)
- steps
  - These are the commands the job will actually run.
  - These can either be terminal commands or other actions you can reference.
  - The uses field is used to denote a reference to another published github action. In this case I am use the checkout action that loads the code from my repository into the workflow, and a node setup action.
  - For the other steps I am just running my npm terminal commands, and specifying env or environment variables for my code to reference.
  - I want to point out the ${{secrets.SECRET_NAME}} entries I have in the env. These are secrets you can add to your Github repository. In this case, they are my API key and base name. Check out more here

Wrap-up

And that is the basics of a workflow file for Github Actions. If you want to know more, be sure to check out the Github Actions Docs.

Feel free to reach out to me if you have any questions and I hope you enjoy automating all those lame tasks 😊

Making interacting with the Airtable API even easier

Graham Vasquez — Sun, 01 Nov 2020 21:51:41 +0000

I am not sure how many of you are familiar with Airtable, but it's an easy to use pseudo database that you can manage like Excel. It supports tons of ways to store different types of data, and allows you to make links between records ala RDBMS. I use it all the time for quick prototyping, or in places where database performance is not a priority and I want an easy way to manage data outside of my application.

They also have a fairly robust API which gives you access to your usual CRUD interface. While this API is pretty easy to use, you can always make it easier right?

Enter the Airtable.js library from Airtable. It makes talking to their API from javascript really easy and quick. The problem is that it's call-back based 🤮. Now I know that this is more of a matter of opinion, but I love me some promises and more so async/await.

Thus I built AsyncAirtable. I just wanted a really easy way to deal with the Airtable API and keep my code nice and clean.

Let's take a quick look at what it looks like to get some data using Airtable.JS"

let results = [];
base('TEST').select({})
  .eachPage(function page(records, fetchNextPage) {
    records.forEach(function(record) {
        results.push(record);
    });
    fetchNextPage();
  }, function done(err) {
    if (err) { console.error(err); return; }
    done();
});

Seems pretty long and verbose. How about if we want to accomplish the same thing with AsyncAirtable?

const results = await asyncAirtable.select('TEST');

These blocks of code will net us the same data. See how easy that is!?

We have built this with all the basic functionality of the Airtable API and a few extra bells and whistles, namely:

Built in pagination
Built in upsert method for you MySQL afficiandos.
Fully typed with declaration files
A handy retry feature that will retry a query if you are rate limited

Now I still have some more ideas for this project to make it even more fun to work with. Let's take a look at some of these:

✨ A QUERY BUILDER ✨

Anyone who has dealt with the Airtable API in the past is probably familiar with filter formula strings. If you are, you are probably just as excited about this as me. The Airtable filter formula strings can get really weird REALLY fast, and can sometimes be hard to follow.

I am working on a query builder that will be more like your traditional ORM such a Sequelize. So you can go from something like:

"AND({name} = 'Graham', {age} > 18, {hungry} = TRUE())"

Now take that and make it something like:

{
  $and: [
    {name: 'Graham'},
    {age: {$gt: 18}},
    {hungry: true}
  ]
}

See? Look at how nice that is!

Let's put it in the context of using a Javscript library to talk to the API.

Here is what that might look like with the Airtable.JS library:

let results = [];
base('TEST').select({
    filterByFormula: "AND({name} = 'Graham', {age} > 18, {hungry} = TRUE())"
}).eachPage(function page(records, fetchNextPage) {
    records.forEach(function(record) {
        results.push(record);
    });
    fetchNextPage();
}, function done(err) {
    if (err) { console.error(err); return; }
    done();
});

Now let's compare that to how you would do the same thing in AsyncAirtable:

const results = await asyncAirtable.select('TEST', {
  where: {
    $and: [
      {name: 'Graham'},
      {age: {$gt: 18}},
      {hungry: true}
    ]
  }
});

It makes query building so much easier. Plus building it programmatically is simpler because it just uses a standard Javascript object instead of having to use messy template strings or worse, string concatenation.

Another feature I am excited to be adding in an upcoming release is data modeling. It won't be as robust as the models used by ORMs like Sequelize, but it will give you some type safety and help you catch errors while you are writing your code, similar to Typescript.

Thanks for reading and I hope you get a chance to test out AsyncAirtable. Be sure you check us out on Github. It is completely open source, so feel free to take a look around, and contribute!

GV14982 / async-airtable

A lightweight npm package to handle working with the Airtable API.

Async Airtable

ARCHIVED

I strongly suggest using the current official Airtable SDK as it now supports promises and I don't really have time to maintain this anymore.

AsyncAirtable is a lightweight npm package to handle working with the Airtable API.

They have an existing library, but it is callback based and can get a little klunky at times, so I wrote this one that is promise based to make your life easier 😊.

I also wrote a query builder so, instead of having to write those really annyoying filter formula strings you can just use an object like:

{
  where: {
    name: 'AsyncAirtable',
    $gte: {stars: 13}
  }
}

which will generate the following filterFormula string for you: AND({name} = 'AsyncAirtable', {stars} >= 13)

Requirements

NodeJS
npm
Airtable account

Installation

Be sure get your API key
To get the base ID of your new base. You can do this by…

View on GitHub

Cheers 🍻