Introduction to the newline guide to building and deploying a REST API using Deno.

Welcome to Build and Deploy a REST API with Deno!

In this lesson, we will install Deno and create our setup for the rest of the course.

How to Install Deno Locally and in Docker Containers

Introduction

Deno vs Node: A Deno Fresh Start to JavaScript Runtimes

We will look at the command line interface for running Deno

How to Use the Deno REPL Command Line Interface

In this lesson, we will look at general usage of Deno by running a file and also introduce the config file

Executing TypeScript Files With Deno With the Config File

Learn how to use the Deno standard library and other external modules with URL imports

Deno vs Golang's Standard Library

How to Start a Deno Server and Set Permissions

You will learn how to make a simple token authentication in Deno

How to Build a Token Authentication Server With Deno

Getting Started with Deno

Using Databases with Deno

How to Use PostgreSQL in Docker with Deno

How to Integrate MySQL or MariaDB With Deno

How to Add SQLite to Deno with deno-sqlite

Connect to a database

Introduction to database migrations - what, why and how

What is Database Migration? The Strategy to Migrate Data

Get started with database migrations using Nessie

How to Add Nessie to Deno to Migrate Databases

We will go through creating a migration using the Nessie CLI

How to Create a New Database Migration With Deno Nessie

We will look at how to write a migration script where we create a table

Edit a Deno Nessie Database Migration to Catch Errors

We will run our migration and learn how to roll back the migration

How to Run and Roll Back a Database Migration With Deno Nessie

We will create a seed file using the Nessie CLI

How to Create a Database Seed File With Deno Nessie

We will run our seed file and populate our database

How to Import JSON Data and Seed a Database With Deno Nessie

Database migrations

Introduction to the concept of REST APIs and why we use them

REST API Introduction

We will go through the thought process of planning an application.

Best Practices for a REST API: Endpoints and Database Schema

We will create the initial project files and set up our environment

How to Prepare Deno to Build a REST API

We will create the router and look at how to test our endpoints

How to Build REST API Endpoints in Deno

It's time to add Nessie! We will now initialize Nessie in our project and also spin up our development database

Integrate a PostgreSQL Database With Nessie Into a Deno API

Time to connect our models to our database!

Building a MySQL or PostgreSQL Database Pool in Deno

In this step, we will create our first data model and create a corresponding table using a migration

Migrating Data to PostgreSQL and Modeling Data in Deno

Creating the methods to access the database

Build API Calls That Generate SQL Queries in Deno

Creating the server endpoints for the Duck namespace

Create a Database Controller in Deno

We will look at how to set up authentication and further authorize the requests

How to Authenticate and Authorize REST API Requests in Deno

We will create two new tables using a migration and create the equivalent models

Create New Tables and Models With Deno Database Migration

We will create our Quack service and controller

Add List, Create, Read, Update, and Delete Requests in Deno

The last stretch! We will create our final namespace, Crumb, and connect it to our other models and our router

How to Build Many-to-Many Namespace Connections in Deno

Now that our application is completed, we will consider some improvements and discuss alternative approaches.

API Afterthoughts

REST API

We will introduce deployments and what we will learn in this module

Deployment Introduction

We will create a Docker image for our application

How to Create a Docker Image to Containerize an Application

You will learn how to create a basic CI file for GitHub and GitLab, and run tests on them

How to Create Continuous Integration Files for GitHub and GitLab

We will deploy our application to a server using CI, SSH and git.

How to Deploy a Deno API Server With the Digital Ocean API

We will deploy our application to Digital Ocean Apps. This is by far the easiest (but most costly) approach.

How to Deploy a Deno Docker Image to Digital Ocean

Similar to how we did it in lesson 1, we will be deploying using CI and SSH, but instead of git, we will be using Docker.

Deploy with Docker

Deployment

In this course, we will learn how to work with [Deno](https://deno.land) to create a REST API using TypeScript with the web framework [Oak](https://github.com/oakserver/oak) and the migration tool [Nessie](https://github.com/halvardssm/deno-nessie). 
Deno is a JavaScript runtime created by [Ryan Dahl](https://tinyclouds.org), the same creator for Node, as an attempt to simplify the JavaScript landscape by strictly following the WebAPI specs. 
If you are interested in learning more about the motivation behind Deno, you can watch this video where Ryan Dahl explains "[10 Things I Regret About Node.js](https://www.youtube.com/watch?v=M3BM9TB-8yA)"

We will explore how to create an application using the powers of TypeScript, and learn how to traverse the Deno ecosystem which is much like the native web ecosystem. 
There are 5 modules that will take you from installing Deno and running your first lines of code, to working with web frameworks and databases, and in the end, deploying your application to a web server using a deployment pipeline.

Throughout this course, you will experience all the different aspects of Deno which you will need to create your own application in the future. 
And from this course, you will get a good feeling for if Deno is ready to be your next default for new projects.

In this course, we will learn how to create and deploy a REST API with Deno from scratch.

Build and deploy a REST API with Deno

Integrating databases into your application

Importance of database migrations in production applications

Deploying Deno applications to production using CICD

Before we get started with this course, it is important to install the tools and
utilities we will need.

First, download VSCode onto your system. You can get it via

Open it, and create a folder anywhere on your computer which will serve as the
course folder. I prefer the path 

, but you are free
to place it wherever you like.

Make sure that VSCode is open in your course folder for the rest of this page
(and this course) as we will set up your workspace properly a bit further
down.

For installing Deno, you have two options; installing locally, or using Docker.

Option A) Installing locally (normal setup)

To install locally, we will start by following the instructions on the

# using shell (MacOS and Linux)
curl -fsSL https://deno.land/install.sh | sh

# using homebrew (MacOS)
brew install deno

# using PowerShell (Windows)
irm https://deno.land/install.ps1 | iex

You should now have Deno installed locally and it should be available in your
shell. You can confirm this by typing 

➜ curl -fsSL https://deno.land/install.sh | sh
######################################################################## 100.0%                                                                
Archive:  /Users/newline/.deno/bin/deno.zip
  inflating: /Users/newline/.deno/bin/deno  
Deno was installed successfully to /Users/newline/.deno/bin/deno
Run 'deno --help' to get started
➜ deno -V                  
deno 1.26.0
➜ deno --version                  
deno 1.26.0 (release, aarch64-apple-darwin)
v8 10.6.194.5
typescript 4.7.4

Recently Deno adopted the docker image from

You can easily run code by executing your code from the shell like this:

docker run -it -p 1993:1993 -v $PWD:/app denoland/deno:1.26.0 run --allow-net /app/main.ts

But if you intend to run Deno from Docker, it can be a good idea to add the
Docker image

,
just remember to update the version now and then.

If you now try to code anything using the Deno syntax, you will quickly see some
invalid syntax errors. Try it out yourself to see what I mean (don't worry about
the code, it is only for illustrative purposes). Create a file named 

import { red } from "https://deno.land/std@0.155.0/fmt/colors.ts";

console.log(red("Hello, World!"));

You should now see some red squiggly lines, complaining that this is not valid
import syntax.

To fix this, we need to add a VSCode extension to enable Deno language support.

After the extension is installed, you want to enable it. Press


to open up the command palette, and type 

, and select yes for all the prompts. Deno should now be enabled
for your workspace!

Reload the VSCode window (open the command palette and select

), and check out the file from before. If everything
worked out and you followed the steps... Oh, wait! The squiggly lines are still
there!

Let's take a closer look at the error we are seeing. If you compare it to the
error we had before, you will see a difference. This time it complains about the
code not being cached, meaning that the Deno syntax is now enabled 🦕 To get rid
of this error, you can run or cache the file, but we will look into this further
on.

 folder in your work directory, so don't forget to


it if you decide to version control your code (I use

This course also includes a code folder (see below). Download and place the code
folder inside your current course folder with a different name (maybe

The code folder serves as a reference to what we are doing throughout the
course, so I recommend only to use it if you are stuck or feel like you missed
something.

For each module, create a folder in your respective course folder, and write
the module code inside.

As a tip: you can version control your course folder with git, and commit your
code after each lesson or module.

Depending on the module, you will either have one codebase for the whole module,
or separate ones for each lesson.

Click here to download the course folder.

We have now set up our development environment, and we are ready to move on to
the next section! 🦕

---
title: How to Install Deno Locally and in Docker Containers
description: In this lesson, we will install Deno and create our setup for the rest of the course.
role: "PROLOGUE"
code: https://gitlab.com/fullstackio/books/newline-course-apps/halvard-morstad-build-and-deploy-a-rest-api-with-deno-app/-/tree/main/code/module_0.1
---

## Setting up our development environment

Before we get started with this course, it is important to install the tools and
utilities we will need.

### Install VSCode

First, download VSCode onto your system. You can get it via
[the website](https://code.visualstudio.com/), or use a package manager like
`brew` or `apt`.

Open it, and create a folder anywhere on your computer which will serve as the
course folder. I prefer the path `~/dev/newline/<course_name>`, but you are free
to place it wherever you like.

> Make sure that VSCode is open in your course folder for the rest of this page
> (and this course) as we will set up your workspace properly a bit further
> down.

### Install Deno

For installing Deno, you have two options; installing locally, or using Docker.

#### Option A) Installing locally (normal setup)

To install locally, we will start by following the instructions on the
[homepage](https://deno.land/). See
[deno_install](https://github.com/denoland/deno_install) for more options.

```shell
# using shell (MacOS and Linux)
curl -fsSL https://deno.land/install.sh | sh

# using homebrew (MacOS)
brew install deno

# using PowerShell (Windows)
irm https://deno.land/install.ps1 | iex
```

You should now have Deno installed locally and it should be available in your
shell. You can confirm this by typing `deno -V` or `deno --version` (for verbose
output, try them both!)

The output should look similar to this:

```shell { actualFilename=./public/assets/snippets.txt endLine=14 startLine=3 url=https&#x3A;//gitlab.com/fullstackio/books/build-a-rest-api-with-deno-and-postgresql/module_01/lesson_01/public/assets/snippets.txt#L3 }
➜ curl -fsSL https://deno.land/install.sh | sh
######################################################################## 100.0%                                                                
Archive:  /Users/newline/.deno/bin/deno.zip
  inflating: /Users/newline/.deno/bin/deno  
Deno was installed successfully to /Users/newline/.deno/bin/deno
Run 'deno --help' to get started
➜ deno -V                  
deno 1.26.0
➜ deno --version                  
deno 1.26.0 (release, aarch64-apple-darwin)
v8 10.6.194.5
typescript 4.7.4
```

#### Option B) Using Docker (advanced setup)

Recently Deno adopted the docker image from
[Andy Hayden](https://github.com/hayd), and made it into their
[official Docker image](https://github.com/denoland/deno_docker).

You can easily run code by executing your code from the shell like this:

```shell
docker run -it -p 1993:1993 -v $PWD:/app denoland/deno:1.26.0 run --allow-net /app/main.ts
```

But if you intend to run Deno from Docker, it can be a good idea to add the
Docker image
[to your shell](https://github.com/denoland/deno_docker#optional-add-deno-alias-to-your-shell),
just remember to update the version now and then.

### VSCode Deno extension

If you now try to code anything using the Deno syntax, you will quickly see some
invalid syntax errors. Try it out yourself to see what I mean (don't worry about
the code, it is only for illustrative purposes). Create a file named `main.ts`,
and add the following to it:

```typescript { actualFilename=../../code/module_0.0/main.ts endChar=103 endLine=4 startChar=0 startLine=1 statedFilename=main.ts url=https&#x3A;//gitlab.com/fullstackio/books/build-a-rest-api-with-deno-and-postgresql/module_01/lesson_01/.../code/module_0.0/main.ts }
import { red } from "https://deno.land/std@0.155.0/fmt/colors.ts";

console.log(red("Hello, World!"));
```

You should now see some red squiggly lines, complaining that this is not valid
import syntax.

![](https://d2uusema5elisf.cloudfront.net/courses/build-and-deploy-a-rest-api-with-deno/module_01/lesson_01/public/assets/vscode_syntax_error.png)

To fix this, we need to add a VSCode extension to enable Deno language support.

In the `Extensions` tab on the left, search for `deno`. You want to install the
one from `denoland`, and you can find the repository
[here](https://github.com/denoland/vscode_deno).

![](https://d2uusema5elisf.cloudfront.net/courses/build-and-deploy-a-rest-api-with-deno/module_01/lesson_01/public/assets/vscode_setup.png)

After the extension is installed, you want to enable it. Press
`ctrl + shift + p` / `cmd + shift + p` or go to `View` -> `Command palette...`
to open up the command palette, and type `deno init`. You should see the
following:

![](https://d2uusema5elisf.cloudfront.net/courses/build-and-deploy-a-rest-api-with-deno/module_01/lesson_01/public/assets/vscode_deno_init.png)

Press `enter`, and select yes for all the prompts. Deno should now be enabled
for your workspace!

Reload the VSCode window (open the command palette and select
`Developer: Reload Window`), and check out the file from before. If everything
worked out and you followed the steps... Oh, wait! The squiggly lines are still
there!

Let's take a closer look at the error we are seeing. If you compare it to the
error we had before, you will see a difference. This time it complains about the
code not being cached, meaning that the Deno syntax is now enabled 🦕 To get rid
of this error, you can run or cache the file, but we will look into this further
on.

You now have a `.vscode` folder in your work directory, so don't forget to
[gitignore](https://www.freecodecamp.org/news/gitignore-what-is-it-and-how-to-add-to-repo/)
it if you decide to version control your code (I use
[this](https://www.toptal.com/developers/gitignore) generator).

```txt { actualFilename=../../code/module_0.0/.gitignore endChar=7 endLine=1 startChar=0 startLine=1 statedFilename=.gitignore url=https&#x3A;//gitlab.com/fullstackio/books/build-a-rest-api-with-deno-and-postgresql/module_01/lesson_01/.../code/module_0.0/.gitignore }
.vscode
```

### Code folder and remote container

This course also includes a code folder (see below). Download and place the code
folder inside your current course folder with a different name (maybe
`code_solutions` or something like that).

The code folder serves as a reference to what we are doing throughout the
course, so I recommend only to use it if you are stuck or feel like you missed
something.

> For each module, create a folder in your respective course folder, and write
> the module code inside.
>
> As a tip: you can version control your course folder with git, and commit your
> code after each lesson or module.

Simple, right!

Depending on the module, you will either have one codebase for the whole module,
or separate ones for each lesson.

> [Click here to download the course folder.](https://api.newline.co/assets/protected/courses/build-and-deploy-a-rest-api-with-deno/downloads/course-full.zip)

We have now set up our development environment, and we are ready to move on to
the next section! 🦕
