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

This second part of the lesson will introduce you to some ways of using Deno. We
will introduce the Deno config file, and also look at how to execute a file.

In our directory, we will create a file called 

. If you are coming from
JavaScript, there are two things you might be wondering about - why this file is
called 

The reasons are simple: Deno is built in Rust, which means that a lot of the
conventions come from the better practices of Rust and not the (debatably worse)
practices of Node. 

 has a lot of expectations in terms of how it works
which is not applicable for Deno (you wont be able to access a file at

// `demo` is a folder with a file `index.js` inside

// Won't work in Deno, but will work in Node
import Something from "./demo";

// Will work in Deno
import Something from "./demo/index.js";

 because of Deno's native support for TypeScript as it parses the
code to JavaScript and caches it before running the code.

 files as it parses TypeScript and
runs JavaScript

However, you don't have to name your files according to any specific naming
convention; after all, it's your program! You can call it whatever you like.


is the Deno style guide if you want to learn more. Common names for entry files
looks like follows:

 in our directory, and our next step
will be to add some code.

Now is the time to run this file and try out the beauty of Deno for the first
time!

From version v1.23 onwards, Deno no longer does automatic typechecking on 

,
but we can ask deno to do this explicitelly by passing the 

➜ deno run --check main.ts
Check file:///Users/newline/course/module_01/main.ts
Hello world!

Congratulations! You have completed the first lesson of this course, and can now
use the basics of Deno! 🎉

As you might have noticed, Deno simply compiles and runs the TypeScript file.
You can read more about it 

At a high level, Deno converts TypeScript (as well as TSX and JSX) into
JavaScript. It does this via a combination of the TypeScript compiler, which
we build into Deno, and a Rust library called 

. When the code has been
type-checked and transformed, it is stored in a cache, ready for the next run,
without the need to convert it from its source to JavaScript again.

Later in the course, we will also take a look at 

, which are two useful commands for when you want to prepare for a
production environment.

I hope you enjoyed the course so far, and that you have learned something new.

If you come from Node, or any kind of prior JS development, you have most likely
used a 

 file before. As we stated previously, Deno does not use a
package manager, and also no local 

 folder, but that does not mean
that there are certain things which would be good to configure. Deno solved this
by adding a config file which can be either in 

 (JSON which
supports comments) format, namely 

). As I
prefer to comment alot, create a file called 

As you can see, we don't by default need anything in this file as everything are
defaulted to the recommended settings (Deno recommends to not add custom config
if you can avoid it). Although we are not really interested in changing any
default config, we want to make things a bit easier for us when executing code,
so we will make use of the

As we did use some commands earlier, we can use the run command as an example.
Add the task to the file as such.

{
  "tasks": {
    "run": "deno run main.ts"
  }
}

Now, you have added your first task! You might notice that this feels odly much
like the 

, but it does not behave
exactly the same. It has some neat extra features which you can read about

➜ deno task run   
Warning deno task is unstable and may drastically change in the future
Task run deno run main.ts
Hello world!

Great! Now you know what the config file is good for, and it's the perfect
replacement for a 

---
title: Executing TypeScript Files With Deno With the Config File
description: In this lesson, we will look at general usage of Deno by running a file and also introduce the config file
code: https://gitlab.com/fullstackio/books/newline-course-apps/halvard-morstad-build-and-deploy-a-rest-api-with-deno-app/-/tree/main/app_with_sqlite_db%20(updated)/module_1.2?ref_type=heads
---

## Using Deno

This second part of the lesson will introduce you to some ways of using Deno. We
will introduce the Deno config file, and also look at how to execute a file.

### Executing a file with Deno

In our directory, we will create a file called `main.ts`. If you are coming from
JavaScript, there are two things you might be wondering about - why this file is
called `main` and not `index`, and why the file has the `.ts` extension instead
of `.js`.

The reasons are simple: Deno is built in Rust, which means that a lot of the
conventions come from the better practices of Rust and not the (debatably worse)
practices of Node. `index` has a lot of expectations in terms of how it works
which is not applicable for Deno (you wont be able to access a file at
`demo/index.js` by importing `demo`).

```ts
// `demo` is a folder with a file `index.js` inside

// Won't work in Deno, but will work in Node
import Something from "./demo";

// Will work in Deno
import Something from "./demo/index.js";
```

We use `ts` because of Deno's native support for TypeScript as it parses the
code to JavaScript and caches it before running the code.

> Deno can handle `js`, `ts`, `jsx`, and `tsx` files as it parses TypeScript and
> runs JavaScript

However, you don't have to name your files according to any specific naming
convention; after all, it's your program! You can call it whatever you like.
[Here](https://deno.land/manual/contributing/style_guide#do-not-use-the-filename-codeindextscodecodeindexjscode)
is the Deno style guide if you want to learn more. Common names for entry files
looks like follows:

| Filename  | Description                                                                                                                                   |
| --------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| `main.ts` | Used by applications to signify the main entry point and where to load the application from                                                   |
| `mod.ts`  | Used by modules as an entry point to signify from where to load components                                                                    |
| `cli.ts`  | Used by modules where a command-line interface is available and serves as an entry point to the CLI                                           |
| `lib.ts`  | Not as widely used as the prior three, but commonly used as an entry point for internally used components, e.g. used by `cli.ts` or `mod.ts`. |

```shell
touch main.ts
```

We now have an empty file called `main.ts` in our directory, and our next step
will be to add some code.

Add a `console.log` to the file and save it.

```typescript { actualFilename=../../code/module_1.0/main.ts endLine=1 startLine=1 statedFilename=main.ts url=https&#x3A;//gitlab.com/fullstackio/books/build-a-rest-api-with-deno-and-postgresql/module_02/lesson_02/.../code/module_1.0/main.ts }
console.log("Hello world!");
```

Now is the time to run this file and try out the beauty of Deno for the first
time!

```shell
deno run main.ts
```

```shell { actualFilename=./public/assets/snippets.txt endLine=4 startLine=3 url=https&#x3A;//gitlab.com/fullstackio/books/build-a-rest-api-with-deno-and-postgresql/module_02/lesson_02/public/assets/snippets.txt#L3 }
➜ deno run main.ts
Hello world!
```

From version v1.23 onwards, Deno no longer does automatic typechecking on `run`,
but we can ask deno to do this explicitelly by passing the `--check` (see docs
[here](<>)) flag.

```shell
deno run --check main.ts
```

```shell { actualFilename=./public/assets/snippets.txt endLine=10 startLine=8 url=https&#x3A;//gitlab.com/fullstackio/books/build-a-rest-api-with-deno-and-postgresql/module_02/lesson_02/public/assets/snippets.txt#L8 }
➜ deno run --check main.ts
Check file:///Users/newline/course/module_01/main.ts
Hello world!
```

Congratulations! You have completed the first lesson of this course, and can now
use the basics of Deno! 🎉

#### TypeScript in Deno

As you might have noticed, Deno simply compiles and runs the TypeScript file.
You can read more about it [here](https://deno.land/manual/typescript/overview),
but to quote Deno:

> At a high level, Deno converts TypeScript (as well as TSX and JSX) into
> JavaScript. It does this via a combination of the TypeScript compiler, which
> we build into Deno, and a Rust library called `swc`. When the code has been
> type-checked and transformed, it is stored in a cache, ready for the next run,
> without the need to convert it from its source to JavaScript again.

Later in the course, we will also take a look at `deno bundle` and
`deno compile`, which are two useful commands for when you want to prepare for a
production environment.

I hope you enjoyed the course so far, and that you have learned something new.

See you in the next lesson!

### Deno config file

If you come from Node, or any kind of prior JS development, you have most likely
used a `package.json` file before. As we stated previously, Deno does not use a
package manager, and also no local `node_modules` folder, but that does not mean
that there are certain things which would be good to configure. Deno solved this
by adding a config file which can be either in `JSON` or `JSONC` (JSON which
supports comments) format, namely `deno.json` and `deno.jsonc` (read more
[here](https://deno.land/manual/getting_started/configuration_file)). As I
prefer to comment alot, create a file called `deno.jsonc`, and add an empty
object.

```jsonc
{}
```

As you can see, we don't by default need anything in this file as everything are
defaulted to the recommended settings (Deno recommends to not add custom config
if you can avoid it). Although we are not really interested in changing any
default config, we want to make things a bit easier for us when executing code,
so we will make use of the
[task runner](https://deno.land/manual/tools/task_runner).

As we did use some commands earlier, we can use the run command as an example.
Add the task to the file as such.

```typescript { actualFilename=../../code/module_1.0/deno.jsonc endChar=51 endLine=6 startChar=0 startLine=1 statedFilename=deno.jsonc url=https&#x3A;//gitlab.com/fullstackio/books/build-a-rest-api-with-deno-and-postgresql/module_02/lesson_02/.../code/module_1.0/deno.jsonc }
{
  "tasks": {
    "run": "deno run main.ts"
  }
}
```

Now, you have added your first task! You might notice that this feels odly much
like the `scripts` property in the `package.json`, but it does not behave
exactly the same. It has some neat extra features which you can read about
[here](https://deno.land/manual/tools/task_runner), but for now lets run our
task.

```shell
deno task run
```

```shell { actualFilename=./public/assets/snippets.txt endLine=17 startLine=14 url=https&#x3A;//gitlab.com/fullstackio/books/build-a-rest-api-with-deno-and-postgresql/module_02/lesson_02/public/assets/snippets.txt#L14 }
➜ deno task run   
Warning deno task is unstable and may drastically change in the future
Task run deno run main.ts
Hello world!
```

Great! Now you know what the config file is good for, and it's the perfect
replacement for a `Makefile` if you only need simple tasks.
