Welcome to Build and Deploy a REST API with Deno!

How to Install Deno Locally and in Docker Containers

Introduction

Deno vs Node: A Deno Fresh Start to JavaScript Runtimes

How to Use the Deno REPL Command Line Interface

Executing TypeScript Files With Deno With the Config File

Deno vs Golang's Standard Library

How to Start a Deno Server and Set Permissions

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

What is Database Migration? The Strategy to Migrate Data

How to Add Nessie to Deno to Migrate Databases

How to Create a New Database Migration With Deno Nessie

Edit a Deno Nessie Database Migration to Catch Errors

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

How to Create a Database Seed File With Deno Nessie

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

Database migrations

REST API Introduction

Best Practices for a REST API: Endpoints and Database Schema

How to Prepare Deno to Build a REST API

How to Build REST API Endpoints in Deno

Integrate a PostgreSQL Database With Nessie Into a Deno API

Building a MySQL or PostgreSQL Database Pool in Deno

Migrating Data to PostgreSQL and Modeling Data in Deno

Build API Calls That Generate SQL Queries in Deno

Create a Database Controller in Deno

How to Authenticate and Authorize REST API Requests in Deno

Create New Tables and Models With Deno Database Migration

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

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

API Afterthoughts

REST API

Deployment Introduction

How to Create a Docker Image to Containerize an Application

How to Create Continuous Integration Files for GitHub and GitLab

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

How to Deploy a Deno Docker Image to Digital Ocean

Deploy with Docker

Deployment

deno

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

In the previous steps, we created a basic Duck interface and connected the
database pool to our application. In this step, we will be adding a way for us
to store and fetch the data we need.

When working on large applications, I usually structure my namespaces as such:

There are other files and conventions, like guards to validate incoming
requests, but we will not discuss them in this guide. In our case we will merge
the 

As with everything else, this is a design decision for our application. If you
really wanted to, you could write everything in one file, but that wouldn't be
very nice to work with as the file would quickly become quite big and
convoluted. But remember, it always depends on your application, so in some
cases it might be better, cleaner, or more efficient to have everything in one
file. In short, it depends!

To get started on the service file, we will add some new imports to our

As we are also using the context of the Oak app to get our postgres client, we
should add a helper function to get this out of the context.

export function getClient(ctx: AppRouterContext): Promise<PoolClient> {
  return ctx.app.state.pool.connect();
}

, it is simply a clone of the state, while

 is the actual global state where you can access the 

As you can see, it would be quite tiresome to write this long chain every time
so with this function, we can quicly return a pool client for us to use.

Lastly before we begin the core of this lesson, we will create a new file

, and add the following imports to it. We will be needing
them for the functions we will create.

import { httpErrors } from "oak";
import { cuid } from "cuid";
import { hash as hashPassword } from "bcrypt";
import type { AppRouterContext } from "../../main.ts";
import { getClient } from "../utils.ts";
import { Duck, DuckKeys } from "./model.ts";

To create a Duck, we need to create a SQL query and also do some data
validation. A Duck also contains a password, and as every good programmer knows,
this shuld never be stored as clear text, but be hashed (not

).
We will discuss password hashing and authentication in two lessons. We also want
to generate an id for every new entry.

export async function createDuck(
  ctx: AppRouterContext,
  data: Partial<Duck>,
): Promise<Duck> {
  if (!data.username) {
    throw new httpErrors.BadRequest("Username is missing from data");
  }
  if (!data.password) {
    throw new httpErrors.BadRequest("Password is missing from data");
  }

  const id = cuid();
  const hashedPassword = await hashPassword(data.password);

  const client = await getClient(ctx);

  const result = await client.queryObject<Duck>({
    text:
      `INSERT INTO ${DuckKeys.TableName} (${DuckKeys.ColId}, ${DuckKeys.ColUsername}, ${DuckKeys.ColPassword}) VALUES ($1, $2, $3) RETURNING *`,
    args: [id, data.username, hashedPassword],
  });

  client.release();

  return result.rows[0] as Duck;
}

We start our function by verifying the incoming data, and as we only have two
fields to worry about, we can make it a bit simple for ourselves. We check if
the username and password is set, and if not, we throw an http error which will
be caught by our error middleware.

---
title: Duck Service
description: Creating the methods to access the database
---

## Duck Service

In the previous steps, we created a basic Duck interface and connected the
database pool to our application. In this step, we will be adding a way for us
to store and fetch the data we need.

When working on large applications, I usually structure my namespaces as such:

-   A `Model` to hold information about the database table and its structure
-   A `DAO`
    ([Data Access Object](https://en.wikipedia.org/wiki/Data_access_object)) to be
    the connection point between the application and the database. This is where
    the queries are placed.
-   A `Service` serving as an entrypoint to the namespace. Usually contains
    distinkt namespace logic, and works as a bridge between the `DAO` and other
    code.
-   A `Controller` to be the entrypoint connected to the endpoints. Uses other
    services to provide logic and data.

There are other files and conventions, like guards to validate incoming
requests, but we will not discuss them in this guide. In our case we will merge
the `DAO` and the `Service` into one file to keep our app simple.

> As with everything else, this is a design decision for our application. If you
> really wanted to, you could write everything in one file, but that wouldn't be
> very nice to work with as the file would quickly become quite big and
> convoluted. But remember, it always depends on your application, so in some
> cases it might be better, cleaner, or more efficient to have everything in one
> file. In short, it depends!

To get started on the service file, we will add some new imports to our
`import_map.json`.

```typescript { actualFilename=../../code/module_4.7/import_map.json endChar=370 endLine=11 startChar=0 startLine=1 statedFilename=import_map.json url=https&#x3A;//gitlab.com/fullstackio/books/build-and-deploy-a-rest-api-with-deno/module_04/lesson_07/.../code/module_4.7/import_map.json }
{
  "imports": {
    "oak": "https://deno.land/x/oak@v11.1.0/mod.ts",
    "dotenv": "https://deno.land/std@0.155.0/dotenv/mod.ts",
    "postgres": "https://deno.land/x/postgres@v0.16.1/mod.ts",
    "nessie": "https://deno.land/x/nessie@2.0.7/mod.ts",
    "cuid": "https://deno.land/x/cuid@v1.0.0/index.js",
    "bcrypt": "https://deno.land/x/bcrypt@v0.4.0/mod.ts"
  }
}
```

As we are also using the context of the Oak app to get our postgres client, we
should add a helper function to get this out of the context.

Add this to our `src/utils.ts` file.

```typescript { actualFilename=../../code/module_4.7/src/utils.ts endLine=36 startLine=34 statedFilename=src/utils.ts url=https&#x3A;//gitlab.com/fullstackio/books/build-and-deploy-a-rest-api-with-deno/module_04/lesson_07/.../code/module_4.7/src/utils.ts#L34 }
export function getClient(ctx: AppRouterContext): Promise<PoolClient> {
  return ctx.app.state.pool.connect();
}
```

> When you access `ctx.state`, it is simply a clone of the state, while
> `ctx.app.state` is the actual global state where you can access the `pool`.

As you can see, it would be quite tiresome to write this long chain every time
so with this function, we can quicly return a pool client for us to use.

Lastly before we begin the core of this lesson, we will create a new file
`src/duck/service.ts`, and add the following imports to it. We will be needing
them for the functions we will create.

```typescript { actualFilename=../../code/module_4.7/src/duck/service.ts endLine=6 startLine=1 statedFilename=src/duck/service.ts url=https&#x3A;//gitlab.com/fullstackio/books/build-and-deploy-a-rest-api-with-deno/module_04/lesson_07/.../code/module_4.7/src/duck/service.ts }
import { httpErrors } from "oak";
import { cuid } from "cuid";
import { hash as hashPassword } from "bcrypt";
import type { AppRouterContext } from "../../main.ts";
import { getClient } from "../utils.ts";
import { Duck, DuckKeys } from "./model.ts";
```

### Create a Duck

To create a Duck, we need to create a SQL query and also do some data
validation. A Duck also contains a password, and as every good programmer knows,
this shuld never be stored as clear text, but be hashed (not
[encrypted](https://stackoverflow.com/questions/326699/difference-between-hashing-a-password-and-encrypting-it)).
We will discuss password hashing and authentication in two lessons. We also want
to generate an id for every new entry.

Here is our implementation for the `createDuck` function:

```typescript { actualFilename=../../code/module_4.7/src/duck/service.ts endLine=33 startLine=8 statedFilename=src/duck/service.ts url=https&#x3A;//gitlab.com/fullstackio/books/build-and-deploy-a-rest-api-with-deno/module_04/lesson_07/.../code/module_4.7/src/duck/service.ts#L8 }
export async function createDuck(
  ctx: AppRouterContext,
  data: Partial<Duck>,
): Promise<Duck> {
  if (!data.username) {
    throw new httpErrors.BadRequest("Username is missing from data");
  }
  if (!data.password) {
    throw new httpErrors.BadRequest("Password is missing from data");
  }

  const id = cuid();
  const hashedPassword = await hashPassword(data.password);

  const client = await getClient(ctx);

  const result = await client.queryObject<Duck>({
    text:
      `INSERT INTO ${DuckKeys.TableName} (${DuckKeys.ColId}, ${DuckKeys.ColUsername}, ${DuckKeys.ColPassword}) VALUES ($1, $2, $3) RETURNING *`,
    args: [id, data.username, hashedPassword],
  });

Creating the methods to access the database

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Build and deploy a REST API with Deno

Module 1: Introduction

Introduction:

Start Here

Introduction:

Welcome to Build and Deploy a REST API with Deno!

Lesson:

How to Install Deno Locally and in Docker Containers

Module 2: Getting Started with Deno

Introduction:

Deno vs Node: A Deno Fresh Start to JavaScript Runtimes

Lesson 1:

How to Use the Deno REPL Command Line Interface

Lesson 2:

Executing TypeScript Files With Deno With the Config File

Lesson 3:

Deno vs Golang's Standard Library

Lesson 4:

How to Start a Deno Server and Set Permissions

Lesson 5:

How to Build a Token Authentication Server With Deno

Module 3: Connect to a database

Introduction:

Using Databases with Deno

Lesson 1:

How to Use PostgreSQL in Docker with Deno

Lesson 2:

How to Integrate MySQL or MariaDB With Deno

Lesson 3:

How to Add SQLite to Deno with deno-sqlite

Module 4: Database migrations

Introduction:

What is Database Migration? The Strategy to Migrate Data

Lesson 1:

How to Add Nessie to Deno to Migrate Databases

Lesson 2:

How to Create a New Database Migration With Deno Nessie

Lesson 3:

Edit a Deno Nessie Database Migration to Catch Errors

Lesson 4:

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

Lesson 5:

How to Create a Database Seed File With Deno Nessie

Lesson 6:

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

Module 5: REST API

Introduction:

REST API Introduction

Lesson 1:

Best Practices for a REST API: Endpoints and Database Schema

Lesson 2:

How to Prepare Deno to Build a REST API

Lesson 3:

How to Build REST API Endpoints in Deno

Lesson 4:

Integrate a PostgreSQL Database With Nessie Into a Deno API

Lesson 5:

Building a MySQL or PostgreSQL Database Pool in Deno

Lesson 6:

Migrating Data to PostgreSQL and Modeling Data in Deno

Lesson 7:

Build API Calls That Generate SQL Queries in Deno

Lesson 8:

Create a Database Controller in Deno

Lesson 9:

How to Authenticate and Authorize REST API Requests in Deno

Lesson 10:

Create New Tables and Models With Deno Database Migration

Lesson 11:

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

Lesson 12:

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

Lesson 1:

API Afterthoughts