DEV Community: Dwi purnomo

TypeORM Connection in NestJS

Dwi purnomo — Wed, 18 Sep 2019 09:55:59 +0000

Post in Indonesian, TypeORM Connection in NestJS.

A software can have a function to save data to database. To save data, usually it uses software such as MySQL, SQLite, or MongoDB with communication using ORM (Object-relational Mapping).

NestJS has three ORM support namely TypeORM, Sequelize and Mongoose. In this tutorial I will only use TypeORM. The advantages of TypeORM in NestJS over other ORMs are that TypeORM and Nest Framework are both built using Typescript language so that they can be well integrated.

Following are the steps to connect a MySQL database to a Nest Framework application using TypeORM:

Install the dependencies.

To begin, we will install the TypeORM dependencies. We will use MySQL as the database.

$ npm install --save @nestjs/typeorm typeorm mysql

Create a database in MySQL.

We will create a database now that will be connected to our Nest application in MySQL.

CREATE DATABASE hello;

Make a Connection Configuration.

Now, we will make a connection configuration in AppModule to connect to our MySQL hello database. Import and use the TypeOrmModule from Nest here.

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'mysql',
      host: 'localhost',
      port: 3306,
      username: 'root',
      password: 'root',
      database: 'hello',
      entities: [__dirname + '/**/*.entity{.ts,.js}']
    }),
  ],
})
export class AppModule {}

Done, our application can be connected to our hello database now. The username and password configuration can be different, adjust it to fit yours.

Additional: TypeORM CLI.

TypeORM has CLI capabilities that can be used to create entities, migrations, etc. If we make a connection configuration like no. 3 above, we cannot use TypeORM's CLI.

As an alternative, we can make a json-based configuration.

Create a file called ormconfig.json at the root of this project, fill in the configuration with:

{
  "type": "mysql",
  "host": "localhost",
  "port": 3306,
  "username": "root",
  "password": "root",
  "database": "hello",
  "entities": ["src/**/*.entity{.ts,.js}"],
}

Once again, The username and password configuration can be different, adjust it to fit yours.

Now, delete the connection configuration inside TypeOrmModule.forRoot() and make it only calls the TypeOrmModule.forRoot()

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';

@Module({
  imports: [TypeOrmModule.forRoot()],
})
export class AppModule {}

Done, now we can use the TypeORM CLI because our application now read the connection configuration from ormconfig.json.

Example REST API with Express.js, Mongoose and Babel

Dwi purnomo — Sun, 30 Jun 2019 02:12:19 +0000

Read on my blog.

This article will discuss an example of making a REST API using Express.js, Mongoose and Babel. The resource or endpoint created is only users. We will only make a simple user registration method. We will use a repository pattern.

Install the package

  yarn add express mongoose mongod
  yarn add --dev @babel/cli @babel/core @babel/node @babel/preset-env nodemon

Create folder structure

.
├── package.json
├── src
│   ├── controllers
│   │   └── UserController.js
│   ├── index.js
│   ├── models
│   │   ├── repositories
│   │   │   └── UserRepository.js
│   │   └── User.js
│   └── routes
│       ├── index.js
│       └── users.js
└── yarn.lock

5 directories, 8 files

User Model User.js

import mongoose from 'mongoose';

const { Schema } = mongoose;

const schema = new Schema({
  email: {
    type: String
  },
  password: {
    type: String
  }
});

const User = mongoose.model('User', schema);
export default User;

User Repository UserRepository.js

Create a repositories folder in the models folder, then create UserRepository.js

import User from '../User';

class UserRepository {

  constructor(model) {
    this.model = model;
  }

  create(object) {
    return this.model.create(object);
  }
}

export default new UserRepository(User);

Then create UserController.js in the controllers folder.

User Controller UserController.js

import UserRepository from '../models/repositories/UserRepository';

function createUser(req, res) {
  const user = req.body;

  UserRepository.create(user)
    .then((newUser) => {
      res.json(newUser);
    }).catch((errors) => {
      res.status(500).json({
        errors,
      });
    });
}

export default { createUser };

After that we list the routes in the routes folder as users.js

User Route users.js

import express from 'express';
import UserController from '../controllers/UserController';

const router = express.Router();

router.post('/', UserController.createUser);

export default router;

And index.js on routes

import express from 'express';
import users from './users';

const router = express.Router();

router.use(express.json());

router.use('/users', users);

export default router;

Finally we create index.js in the src

Server index.js

import express from 'express';
import mongoose from 'mongoose';

import routes from './routes';

mongoose.Promise = global.Promise;

const app = express();

app.use('/', routes);

mongoose.connect('mongodb://localhost:27017/db')
  .then(() => {
    console.log('mongodb started.');
    app.listen(8000, () => {
      console.log('Server started on 8000');
    });
  }).catch(() => {
    console.log('Mongodb connection failed.');
  })

Command to run the server

nodemon -w src -x "babel-node src --presets @babel/env"

We can add it to npm-scripts in package.json

{
  "name": "exercise",
  "version": "1.0.0",
  "main": "index.js",
  "license": "MIT",
  "dependencies": {
    "express": "^4.17.1",
    "mongodb": "^3.2.7",
    "mongoose": "^5.6.2",
    "nodemon": "^1.19.1"
  },
  "devDependencies": {
    "@babel/cli": "^7.4.4",
    "@babel/core": "^7.4.5",
    "@babel/node": "^7.4.5",
    "@babel/preset-env": "^7.4.5"
  },
  "scripts": {
    "start": "nodemon -w src -x \"babel-node src --presets @babel/env\""
  }
}

That was practicing express.js, mongoose and babel using a simple REST API. The entire code can be seen at https://github.com/yoiso/exercise-express

How to Create Role based Authorization Middleware with Casbin and Nest.js

Dwi purnomo — Sat, 11 May 2019 13:53:21 +0000

Read on my site.

In this article, i will show you how to create Role based authorization middleware with Casbin and Nest.js. Casbin is an authorization library that supports access control models like ACL, RBAC, ABAC for Golang, Java, PHP and Node.js, but in this article, we will use the Node.js.

Nest is a progressive Node.js framework for building efficient, reliable and scalable server-side applications. It uses Typescript language and support multiple core server like Express, Koa or Fastify.

If you prefer to watch in video format:

Here is the text format:

Before we create the project, install Nest first.

npm i -g @nestjs/cli

And then we create a project with the Nest cli

nest new theproject

Then, open the project directory and install the Casbin

cd theproject
npm install --save casbin

After this, we enter the coding phase.

First, create the policy configuration for Casbin.

In the src, create a directory named casbin_conf.

cd src
mkdir casbin_conf

Create model.conf and policy.csv in the casbin_conf

File model.conf:

[request_definition]
r = sub, obj, act

[policy_definition]
p = sub, obj, act

[policy_effect]
e = some(where (p.eft == allow))

[matchers]
m = r.sub == p.sub && keyMatch(r.obj, p.obj) && (r.act == p.act || p.act == "*")

File policy.csv:

p, admin, /*, GET
p, notadmin, /, POST

In the policy we define two rules, one is for user who have admin role and the other is for user who have notadmin role.

After that, we create the Nest middleware.

Create a middleware named authorization.middleware.ts in src

File authorization.middleware.ts:

import { Enforcer } from 'casbin';

export class BasicAuthorizer {
    private req: any;
    private enforcer: any;

    constructor(req, enforcer) {
        this.req = req;
        this.enforcer = enforcer;
    }

    getUserRole() {
        const { user } = this.req;
        const { role } = user;
        return role;
    }

    checkPermission() {
        const { req, enforcer } = this;
        const { originalUrl: path, method } = req;
        const userRole = this.getUserRole();
        return enforcer.enforce(userRole, path, method);
    }
}

// the authorizer middleware
export function authz(newEnforcer: () => Promise<Enforcer>) {
    return async (req, res, next) => {
        const enforcer = await newEnforcer();

        // user sample
        req.user = {role: 'admin'};

        if(!(enforcer instanceof Enforcer)) {
            res.status(500).json({500: 'Invalid enforcer'});
            return;
        }

        const authorizer = new BasicAuthorizer(req, enforcer);
        if(!authorizer.checkPermission()) {
            res.status(403).json({403: 'Forbidden'});
            return;
        }

        next();
    }
};

That's the authorization middleware logic, Casbin will help checking the permission.

Then we integrate the middleware in Nest project bootstrap.

Find the maint.ts, integrate the authorization middleware in the app:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

import { newEnforcer } from 'casbin';
import { authz } from './authorization.middleware';

import { join } from 'path';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  // authorization middleware that is registered as global middleware
  app.use(authz(async() => {
      const enforcer = await newEnforcer(join(__dirname, 'casbin_conf/model.conf'), join(__dirname, 'casbin_conf/policy.csv'));
      return enforcer;
  }));
  await app.listen(3000);
}
bootstrap();

That is the authorization middleware that is registered as global middleware in the app.

Boot up the project to test:

npm run start:dev

If you want to experiment, modify the sample user in the authz, remove that if you want make it into production.

Here is the project repository.

Hi, I'm Dwi purnomo

Dwi purnomo — Sat, 03 Jun 2017 16:42:25 +0000

You can find me on Gitlab as brspd

I live in Yogyakarta, Indonesia.

I mostly program in these languages: php.

I am currently learning more about REST API.

Nice to meet you.