NodeJS Design Pattern

Why do a project need to design patterns?

First of all, if the project is applied a good pattern when we start the coding. It is very useful for maintaining, updating code and building new features. You can re-use the functions that you created. Also, if you define a good pattern at the beginning, you will avoid duplicated code and save a lot of time when you update or change functions.

The libraries will be used

In this article, you will learn a sample pattern. It is a simple project that I built. This project uses express js, a simple web application framework. You can find the instruction for installing at below link https://expressjs.com/en/starter/installing.html

The libraries that were used for the project:

• Express is a minimal and flexible Node.js web application framework.
• TypeORM is an ORM that can run in NodeJS. It supports many databases. So, you don't need to care about SQL query, it will help. You just need a defined model table, it will generate the SQL.
• Typescript is a strongly typed programming language that builds on JavaScript. You can define classes and extend classes more easily.

The folder structure in project

This is the architecture that we will use for my project.

• app contains the files that last step is render api
• core contains each module. In each modules, it contains such as model, repository
• infrastructure contains the services that use for all module

In this folder structure, we organize each module. By this way, I think it works out pretty well and finding the target that you want to code is easier. We will put the model, repository or request filter to each module like in the image below.

Explanation each folder

Now, we will talk about folder infrastructure, it will share all functions for each module.

First, the folder repositories contain all functions that connect to the database. The general functions query the records in each table of the database such as all models find a specific record, all records, create new item or update, delete an existing item.

import { PostRepositoryInterface } from "./PostRepositoryInterface";
import { PostModel } from "./PostModel";
import { GenericRepository } from "../../infrastructure/repositories/generic/GenericRepository";
import { AppDataSource } from "../../infrastructure/repositories/dataSource/AppDataSource";
import { PostPosition } from "./PostPosition";

export class PostRepository extends GenericRepository<PostModel> implements PostRepositoryInterface
{
    constructor()
    {
        super(AppDataSource.getRepository(PostModel));
    }

    getLatest(total: number): Promise<PostModel[]>
    {
        return this.repository.find({
            order: {
                id: "DESC",
            },
            take: total
        });
    }

    getFeature(total: number): Promise<PostModel[]> { }

    findByIdIncludeUser(id: number): Promise<PostModel|null> { }
}

The above image is the interface of GenericRepository class, you can find the code that executes on each function on my github https://github.com/luan4637/node-vue-blog

We move on to the module that will use the GenericRepository class. We will take the post module for example to extend the GenericRepository class. Also, there are categories and user module in the source code, they are similar together.

import { FindOptionsWhere } from 'typeorm';
import { PaginationResult } from '../../services/pagination/PaginationResult';
import { FilterInterface } from '../../services/filter/FilterInterface';

export interface GenericRepositoryInterface<T>
{
    findAll(): Promise<T[]>;

    find(take?: number, skip?: number): Promise<[T[], number]>;

    paging(filter: FilterInterface): Promise<PaginationResult<T>>;

    findOne(where: FindOptionsWhere<T>): Promise<T|null>;

    findById(id: number): Promise<T|null>;

    save(item: T): Promise<T>;

    update(id: number, newItem: T): Promise<T|null>;

    delete(id: number): Promise<T|null>;
}

This is a post module that extends GenericRepository. It is placed on the core folder. Also, there are a few functions that use other logic that is different on the GenericRepository, they just use only this module.

In this module, I created a class PostFilter for filtering the query string on the request. They will find records that match with conditions on the table.

import { Like, FindManyOptions, FindOperator } from "typeorm";
import { FilterInterface } from "../../infrastructure/services/filter/FilterInterface";
import { CategoryModel } from "../category/CategoryModel";

export class PostFilter implements FilterInterface
{
    private query: PostFilterQuery;

    constructor(query: PostFilterQuery)
    {
        this.query = query;
    }

    getCategory(): string
    {
        return this.query.category;
    }

    getTitle(): string
    {
        return this.query.title;
    }

    getContent(): string
    {
        return this.query.content;
    }

    getPublished(): boolean
    {
        return this.query.published;
    }

    getPosition(): string
    {
        return this.query.position;
    }

    getPage(): number
    {
        return this.query.page;
    }

    getLimit(): number
    {
        return this.query.limit;
    }

    getFindOptions(): FindManyOptions
    {
        const limit:number = this.getLimit() ?? 10;
        const page:number = this.getPage() > 0 ? this.getPage() : 1;

        let whereClauses = <OperatorWhereClauses>{}
        if (this.getTitle() !== undefined) {
            whereClauses.title = Like(`%${this.getTitle()}%`);
        }
        if (this.getPublished() !== undefined) {
            whereClauses.published = this.getPublished();
        }
        if (this.getPosition() !== undefined) {
            whereClauses.position = this.getPosition();
        }
        if (this.getCategory() !== undefined) {
            const category = { slug: this.getCategory() } as CategoryModel;
            whereClauses.categories = [category];
        }
        
        const findOptions: FindManyOptions = {
            relations: ['user', 'categories'],
            take: limit,
            skip: (page - 1) * limit,
            where: whereClauses
        };

        return findOptions;
    }
}

interface OperatorWhereClauses {
    title: FindOperator<string>,
    published: boolean,
    position: string,
    categories: CategoryModel[]
}

interface PostFilterQuery {
    category: string;
    title: string;
    content: string;
    published: boolean;
    position: string;
    page: number;
    limit: number;
}

Also, you will see the function getFindOptions in this PostFilter class. It was implemented in the interface FilterInterface class. This function will be used in the GenericRepository class. So, this function getFindOptions must be required in all filter classes.

In every module, you will need an api for list all the records with pagination of a particular table. You will find the function paging on the GenericRepository class. It will return the class PaginationResult that has a specific key name of response json. It is a standard for frontend developers to use the response json.

Conclude

You will see on each function of the controller, there is very small line code. Because, they were processed on each module. So, it is very helpful when you build a large project that is maintained easily.

You can find the source code in the article on my github at below link https://github.com/luan4637/node-vue-blog