Let's learn Node.js by building a backend with Nest.js and Sequelize
Tags: node, javascript, postgres, beginners
Published: 2020-05-27 12:35:13

This article was originally published at https://www.blog.duomly.com/node-js-course-with-building-a-fintech-banking-app-lesson-1-start-the-project

--- 

In the previous week, I and my friend started to build a project divided for two courses - <a href="https://www.blog.duomly.com/golang-course-with-building-a-fintech-banking-app-lesson-1-start-the-project/">backend with Golang</a> and <a href="https://www.blog.duomly.com/angular-course-building-a-banking-application-with-tailwind-css-lesson-1-start-the-project/">frontend with Angular 9</a>. In the meantime, we got the idea to give you an alternative for a Golang course, and show you how to build a similar backend using Node.js.

In this article, we are going to start by setting up the Nest.js project, connecting with the PostgreSQL database and make migrations.

In this course, we will be using Nest.js which is a typescript framework, kind of an Angular for Node.js. It's very comfortable and easy to use, so in my opinion, it's a great choice for beginners.

Besides that, we will use Sequelize for database maintaining and Umzug for migrations. We've selected a PostgreSQL database so it will be great if you could create an empty one to start the project.

I can't wait to get started, but before that, as always I have to mention that we've got a video version for you on our Youtube channel for you.

{% youtube y5MN8tcpevA%}

Let's crush Node.js!

###1. What do you need to start Node.js project?###

Let's start by clarifying what's important for you to start with us from point 2. 

To be able to create a Node.js application you will need Node.js installed. <a href="https://nodejs.org/en/">Here</a> you can take a look at the official documentation and download the installer.  

The second important thing you need is a PostgreSQL database installed and created for the purpose of this application. 

Another thing which would be rather useful then required is the database tool like DBeaver.

If you've got everything ready, let's start a real fun.

###2. Installing Nest.js CLI and creating a project###

At the beginning let's install Nest.js CLI which will be useful to create a new project. For this use the following command: 

```
$ npm i -g @nestjs/cli
```

When it's ready, we can create a new project. I called my project lesson-one but feel free to call it how you like.

```
$ nest new lesson-one
```
When it's  done go into the newly created folder and let's add another needed packages!

###3. Add Sequalize and Umzug###

For database and migrations, we will use Sequalize and Umzug, so we need to install them now!

So, let's start by installing Sequelize and Sequelize Typescript with the following command: 

```
$ npm install --save sequelize sequelize-typescript
$ npm install pg
```

After the installation is done, there can be two missing dependencies, which we have to install manually. Let's use the following command to do this:

```
$ npm install @types/bluebird
$ npm install @types/validator
```

If you didn't have that problem skip this step and continue with installing Umzug.

```
 $ npm install umzug
```

Great, when it's done we can run our backend and start coding. To run Nest.js we use `nest start`.

###4. Create database module###

Let's start by creating a new folder in our `./src` folder and let's call it `modules`. When you did it, please inside that folder create another one and call it `database`.

In the `./src/modules/database` let's create two files, `database.module.ts` and `database.provider.ts` and let's start from the provider, and let's add the following code there.

```typescript
import { Sequelize } from 'sequelize-typescript';

export const databaseProvider = [
  {
    provide: 'SEQUELIZE',
    useFactory: async () => {
      const sequelize = new Sequelize({
        dialect: 'postgres',
        host: <YOUR_HOST>,
        port: 5432,
        username: <YOUR_USERNAME>,
        password: <YOUR_PASSWORD>,
        database: <YOUR_DB_NAME>
      });
      sequelize.addModels([]);
      return sequelize;
    }
  }
]
```

Remember to change the placeholders and set your own database credentials.
When you finished, let's open `database.module.ts` and add there the code as you see below.

```typescript
import { Module } from '@nestjs/common';
import { databaseProvider } from './database.provider';

@Module({
  providers: [...databaseProvider],
  exports: [...databaseProvider]
})

export class DatabaseModule { }
```
Great, the last element in this step is adding a database module to our `app.module.ts` file, so let's open it and make sure your code looks like this.

```typescript
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { DatabaseModule } from './modules/database/database.module';

@Module({
  imports: [
    DatabaseModule,
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}
```

###5. Create migrations###

Now, we are going to set up the migration file. Let's go to the root file of the project and create a `migrate.ts` file. Inside this file, we will connect with the database and set an instance of the umzug. 

```typescript
import { Sequelize } from 'sequelize-typescript';
import Umzug = require('umzug');

const sequelize = new Sequelize({
  dialect: 'postgres',
  host: 'YOUR_HOST',
  port: 5432,
  username: 'YOUR_USERNAME',
  password: 'YOUR_PASSWORD',
  database: 'YOUR_DB_NAME'
});

const umzug = new Umzug({
  storage: 'sequelize',
  storageOptions: { sequelize },
  logging: false,
  migrations: {
    params: [
      sequelize,
      sequelize.constructor,
    ],
    path: './src/migrations',
    pattern: /\.ts$/,
  },
});

const task = (process.argv[2] || '').trim();

switch (task) {
  case 'up':
    umzug.up()
      .then((result) => {
        console.log('Migrations up went successful!', result);
        process.exit(0);
      });
    break;
  case 'down':
    umzug.down()
      .then((result) => {
        console.log('Migrations down went successful!', result);
        process.exit(0);
      });
    break;
  default:
    break;
};
```

Great, now we will create a folder for migrations in the `./src` folder. Inside the new folder, we will create two files for the two tables we would like to create in our database. Let's call them `1.1users.ts` and `1.2accounts.ts`.

In the first file, we will create `up()` and `down()` functions. Let's use the following code in the `1.1users.ts` file:

```typescript
import * as Sequelize from 'sequelize';

const tableName = 'Users';

export async function up(i: any) {
  const queryInterface = i.getQueryInterface() as Sequelize.QueryInterface;
  queryInterface.createTable(tableName, {
    id: {
      type: Sequelize.INTEGER,
      allowNull: false,
      autoIncrement: true,
      unique: true,
      primaryKey: true,
    },
    Username: {
      type: Sequelize.CHAR(200),
      allowNull: false,
    },
    Email: {
      type: Sequelize.CHAR(50),
      allowNull: false,
    },
    Password: {
      type: Sequelize.CHAR(250),
      allowNull: false,
    },
  });
};

export async function down(i: any) {
  const queryInterface = i.getQueryInterface() as Sequelize.QueryInterface;
  queryInterface.dropTable(tableName);
}
```

And code in the `1.2accounts.ts` file will be very similar: 

```typescript
import * as Sequelize from 'sequelize';

const tableName = 'Accounts';

export async function up(i: any) {
  const queryInterface = i.getQueryInterface() as Sequelize.QueryInterface;
  queryInterface.createTable(tableName, {
    id: {
      type: Sequelize.INTEGER,
      allowNull: false,
      autoIncrement: true,
      unique: true,
      primaryKey: true,
    },
    Type: {
      type: Sequelize.CHAR(200),
      allowNull: false,
    },
    Name: {
      type: Sequelize.CHAR(200),
      allowNull: false,
    },
    Balance: {
      type: Sequelize.INTEGER,
      allowNull: true,
    },
    UserId: {
      type: Sequelize.INTEGER,
      references: {
        model: 'Users',
        key: 'id',
      },
    },
  });
};

export async function down(i: any) {
  const queryInterface = i.getQueryInterface() as Sequelize.QueryInterface;
  queryInterface.dropTable(tableName);
}
```
We are almost there, there is just one step to finish.
Let's open `package.json` file and let's add a new command: 
```json
"scripts": {
    "migrate": "ts-node ./migrate.ts",
...
}
```
Now we are ready to run the migrations. 

###6. Running migrations###

Running migrations is the last step in this lesson. Let's open the console and run the following code to do migrations: 

```
$ npm run migrate up
```

After it's finished you can check your database in any database tool like DBeaver and you will see two new tables, connected by UserId.

Now, you can check if migrations down work as well. Undoing the migrations works one by one, so if you did migrations for two tables you need to run migrate down twice to undo both tables.

To undo the migration run the following command:

```
$ npm run migrate down
```

When it's done you can check if your tables are undone. 

###Conclusion###

Congratulations, you've just finished the first lesson of our Node.js course, and your project is ready for building an API.

In the next lesson, we will be building a registration feature.

If you didn't manage to get the code correctly you can check it out in our Github repository for this lesson: 

https://github.com/Duomly/nodejs-backend-bankapp/tree/Nodejs-Course-Lesson1

I hope you like the new skills you got today and will join us for the next lessons.

If you'd like to build the backend in Golang, check out my friend's course right here:

<a href="https://www.blog.duomly.com/golang-course-with-building-a-fintech-banking-app-lesson-1-start-the-project/">Golang Course</a>

We are also creating a front-end for this application in Angular 9 which you can check here: 

<a href="https://www.blog.duomly.com/angular-course-building-a-banking-application-with-tailwind-css-lesson-1-start-the-project/">Angular Course</a>

<a href="https://www.duomly.com">![Duomly - Programming Online Courses](https://dev-to-uploads.s3.amazonaws.com/i/d0k5cv5lqetakmym6zvu.jpg)</a>

Thank you for reading,
Anna from Duomly