Node.js Course With Building a Fintech Banking App – Lesson 1: Start the Project

$ npm i -g @nestjs/cli

$ nest new lesson-one

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

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

$ npm install umzug

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;
    }
  }
]

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.

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.

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:

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:

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:

  {
    "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 Node.js course – Lesson 1:

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