Tạo REST API trên Nodejs với Express và Prisma sử dụng Typescript

├── .vscode
│   └── settings.json
└── .prettierrc.json

{
  "editor.defaultFormatter": "esbenp.prettier-vscode"
}

{
  "trailingComma": "all",
  "tabWidth": 2,
  "semi": true,
  "singleQuote": false
}

npm init

{
  "name": "express-prisma-typescript-boilerplate",
  "version": "1.0.0",
  "description": "",
  "main": "src/index.ts",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "kienmatu",
  "license": "ISC",
  "repository": {
    "type": "git",
    "url": "git+https://github.com/kienmatu/express-prisma-typescript-boilerplate.git"
  }
}

npm i typescript

//...
"dependencies": {
    "typescript": "^4.6.2"
  }

npx tsc --init

// "outDir": "./",

"outDir": "./dist",

{
  "compilerOptions": {
    "target": "es2019",
    "module": "commonjs",
    "outDir": "dist",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}

npm i cross-env dotenv express rimraf

npm i @types/express @types/node

npm i --save-dev concurrently nodemon

"scripts": {
  "build": "rimraf dist && tsc",
  "predev": "npm run build",
  "dev": "cross-env NODE_ENV=development concurrently \"tsc --watch\" \"nodemon -q dist/index.js\"",
  "prestart": "npm run build",
  "start": "cross-env NODE_ENV=production node dist/index.js",
  "test": "echo \"Error: no test specified\" && exit 1"
},

{
  "name": "express-prisma-typescript-boilerplate",
  "version": "1.0.0",
  "description": "",
  "main": "src/index.ts",
  "scripts": {
    "build": "rimraf dist && tsc",
    "predev": "npm run build",
    "dev": "cross-env NODE_ENV=development concurrently \"tsc --watch\" \"nodemon -q dist/index.js\"",
    "prestart": "npm run build",
    "start": "cross-env NODE_ENV=production node dist/index.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "kienmatu",
  "license": "ISC",
  "repository": {
    "type": "git",
    "url": "git+https://github.com/kienmatu/express-prisma-typescript-boilerplate.git"
  },
  "dependencies": {
    "@types/express": "^4.17.13",
    "@types/node": "^17.0.21",
    "cross-env": "^7.0.3",
    "dotenv": "^16.0.0",
    "express": "^4.17.3",
    "rimraf": "^3.0.2",
    "typescript": "^4.6.2"
  },
  "devDependencies": {
    "concurrently": "^7.0.0",
    "nodemon": "^2.0.15"
  }
}

console.log("xin chào các bạn");

npm run dev

import express, { Express, Request, Response } from "express";
import dotenv from "dotenv";

dotenv.config();

const PORT = process.env.PORT || 3000;
const app: Express = express();

app.use(express.json());

app.get("/", (req: Request, res: Response) => {
  res.send("<h1>Nhiệt liệt chào mừng quý vị đại coder!</h1>");
});

app.listen(PORT, () => console.log(`Running on ${PORT} ⚡`));

"use strict";
var __importDefault =
  (this && this.__importDefault) ||
  function (mod) {
    return mod && mod.__esModule ? mod : { default: mod };
  };
Object.defineProperty(exports, "__esModule", { value: true });
var express_1 = __importDefault(require("express"));
var dotenv_1 = __importDefault(require("dotenv"));
dotenv_1.default.config();
var PORT = process.env.PORT || 3000;
var app = (0, express_1.default)();
app.use(express_1.default.json());
app.get("/", function (req, res) {
  res.send("<h1>Nhiệt liệt chào mừng quý vị đại coder!</h1>");
});
app.listen(PORT, function () {
  return console.log("Running on ".concat(PORT, " \u26A1"));
});

import * as express from "express";
export abstract class BaseController {
  public router: express.Router;

  constructor() {
    this.router = express.Router();
  }
  public abstract initializeRoutes(): void;
}

import express from "express";
import { BaseController } from "./abstractions/base-controller";

export default class HeroController extends BaseController {
  public path = "/heroes";

  constructor() {
    super();
    this.initializeRoutes();
  }

  public initializeRoutes() {
    this.router.get(this.path, this.getAllHero);
    this.router.post(this.path, this.addHero);
    // Bạn có thể thêm put, patch, delete sau.
  }
  getAllHero = async (request: express.Request, response: express.Response) => {
    response.json(request.body);
  };
  addHero = async (request: express.Request, response: express.Response) => {
    response.json(request.body);
  };
}

import express from "express";
import { BaseController } from "./controllers/abstractions/base-controller";

class App {
  public app: express.Application;
  public port: number | string;

  constructor(controllers: BaseController[], port: number | string) {
    this.app = express();
    this.port = port;

    this.initializeMiddlewares();
    this.initializeControllers(controllers);
  }

  private initializeMiddlewares() {
    this.app.use(express.json());
  }

  private initializeControllers(controllers: BaseController[]) {
    this.app.get("/", (request, response) => {
      response.send("Application is running");
    });
    controllers.forEach((controller) => {
      this.app.use("/", controller.router);
    });
  }

  public listen() {
    this.app.listen(this.port, () => {
      console.log(`App listening on the port ${this.port}`);
    });
  }
}

export default App;

import dotenv from "dotenv";
import App from "./app";
import HeroController from "./controllers/hero-controller";

dotenv.config();

const port = process.env.PORT || 3000;
const app = new App([new HeroController()], port);

app.listen();

services:
  postgres:
    image: postgres
    container_name: postgres_db_container
    environment:
      - POSTGRES_DB=${POSTGRES_DB:-postgres}
      - POSTGRES_USER=${POSTGRES_USER:-postgres}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-password1}
    ports:
      - "5432:5432"
    restart: unless-stopped

docker-compose up -d postgres

docker ps

npm install prisma @prisma/client

npx prisma init

// This is your Prisma schema file,
// learn more about it in the docs: https://pris.ly/d/prisma-schema

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

PORT=3000

# This was inserted by `prisma init`:

# Environment variables declared in this file are automatically made available to Prisma.

# See the documentation for more detail: https://pris.ly/d/prisma-schema#accessing-environment-variables-from-the-schema

# Prisma supports the native connection string format for PostgreSQL, MySQL, SQLite, SQL Server, MongoDB (Preview) and CockroachDB (Preview).

# See the documentation for all the connection string options: https://pris.ly/d/connection-strings

DATABASE_URL="postgresql://johndoe:randompassword@localhost:5432/mydb?schema=public"

DB_HOST=localhost
DB_PORT=5432
DB_SCHEMA=public
POSTGRES_USER=postgres
POSTGRES_PASSWORD=password1
POSTGRES_DB=hero_db

# See the documentation for all the connection string options: https://pris.ly/d/connection-strings

DATABASE_URL=postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${DB_HOST}:${DB_PORT}/${POSTGRES_DB}?schema=${DB_SCHEMA}&sslmode=prefer

// This is your Prisma schema file,
// learn more about it in the docs: https://pris.ly/d/prisma-schema

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

model Hero {
  id            Int      @id @default(autoincrement())
  createdAt     DateTime @default(now())
  updatedAt     DateTime @updatedAt
  name          String   @db.VarChar(255)
  origin        String?  @db.VarChar(255)
  description   String?
}

npx prisma migrate dev --name init

import { PrismaClient } from "@prisma/client";
import * as express from "express";
export abstract class BaseController {
  public router: express.Router;
  public prisma: PrismaClient;

  constructor() {
    this.prisma = new PrismaClient();
    this.router = express.Router();
  }
  public abstract initializeRoutes(): void;
}

getAllHero = async (request: express.Request, response: express.Response) => {
  const heroes = await this.prisma.hero.findMany();
  response.json(heroes);
};

addHero = async (request: express.Request, response: express.Response) => {
  const reqBody = request.body;
  const hero = await this.prisma.hero.create({
    data: {
      name: reqBody.name,
      origin: reqBody.origin,
      description: reqBody.description,
    },
  });
  response.json(hero);
};

  public initializeRoutes() {
    this.router.get(this.path, this.getAllHero);
    this.router.post(this.path, this.addHero);
    this.router.get(this.path + "/:heroId", this.getHeroById);
    // Bạn có thể thêm put, patch, delete sau.
  }

  getHeroById = async (
    request: express.Request,
    response: express.Response,
  ) => {
    const hero = await this.prisma.hero.findUnique({
      where: {
        id: Number.parseInt(request.params.heroId),
      },
    });
    response.json(hero);
  };

export default class HttpException extends Error {
  status: number;
  message: string;
  constructor(status: number, message: string) {
    super(message);
    this.status = status;
    this.message = message;
  }
}

import { NextFunction, Request, Response } from "express";
import HttpException from "../exceptions/http-exception";

export default function errorMiddleware(
  error: HttpException,
  request: Request,
  response: Response,
  next: NextFunction
) {
  const status = error.status || 500;
  const message = error.message || "Something went wrong";
  response.status(status).json({
    status,
    message,
  });
}

import express from "express";
import { BaseController } from "./controllers/abstractions/base-controller";
import errorMiddleware from "./middlewares/error.middleware";

class App {
  public app: express.Application;
  public port: number | string;

  constructor(controllers: BaseController[], port: number | string) {
    this.app = express();
    this.port = port;

    this.initializeMiddlewares();
    this.initializeControllers(controllers);
    this.initializeErrorHandling();
  }

  private initializeMiddlewares() {
    this.app.use(express.json());
  }

  private initializeErrorHandling() {
    this.app.use(errorMiddleware);
  }

  private initializeControllers(controllers: BaseController[]) {
    this.app.get("/", (request, response) => {
      response.send("Application is running");
    });
    controllers.forEach((controller) => {
      this.app.use("/", controller.router);
    });
  }

  public listen() {
    this.app.listen(this.port, () => {
      console.log(`App listening on the port ${this.port}`);
    });
  }
}

export default App;

import HttpException from "./http-exception";

class HeroNotFoundException extends HttpException {
  constructor(id: number) {
    super(404, `Hero with id ${id} not found`);
  }
}

export default HeroNotFoundException;

//...
getHeroById = async (
  request: express.Request,
  response: express.Response,
  next: express.NextFunction
) => {
  const heroId = Number.parseInt(request.params.heroId);
  this.prisma.hero
    .findUnique({
      where: {
        id: heroId,
      },
    })
    .then((hero) => {
      if (hero) {
        response.json(hero);
      } else {
        next(new HeroNotFoundException(heroId));
      }
    });
};

"scripts": {
    //..
    "deploy": "npx prisma migrate deploy && npm run start",
  },

FROM node:16-alpine3.14

EXPOSE 3000

ARG NODE_ENV
ENV NODE_ENV $NODE_ENV

RUN mkdir /app
WORKDIR /app
ADD package.json yarn.lock .env /app/
ADD . /app
RUN yarn --pure-lockfile

CMD ["yarn", "deploy"]

services:
  postgres:
    image: postgres
    container_name: postgres_db_container
    environment:
      - POSTGRES_DB=${POSTGRES_DB:-postgres}
      - POSTGRES_USER=${POSTGRES_USER:-postgres}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-password1}
    ports:
      - "5432:5432"
    restart: unless-stopped
  api:
    container_name: boiler_api_container
    build: .
    ports:
      - "3000:3000"
    depends_on:
      - postgres

DB_HOST=postgres

generator client {
  provider = "prisma-client-js"
  binaryTargets = ["native", "linux-musl"]
}

docker-compose up -d

node_modules
.env
dist