Pengendalian ralat tersuai dalam API REST menggunakan TypeScript, Express.js, pengesahan Joi dan pengaturcaraan berorientasikan objek

Hai, Devs!

Membina API REST yang teguh dan boleh diselenggara memerlukan pertimbangan yang teliti terhadap pengendalian ralat, pengesahan dan struktur. Dalam artikel ini, kami akan meneroka cara menyediakan mekanisme pengendalian ralat tersuai dalam API REST menggunakan TypeScript, Express.js, Joi untuk pengesahan dan prinsip pengaturcaraan berorientasikan objek (OOP). Kami akan menstrukturkan projek kami seperti berikut:

Skruktur:

---src
-----peranti tengah
--------ErrorHanlder.ts
-----model
--------User.ts
-----repositori
--------UserRepository.ts
-----laluan
--------UserRouter.ts
-----pengawal
--------UserController.ts
-----perkhidmatan
--------UserService.ts
-----pengesahan
--------UserValidation.ts
---app.ts
---server.ts

Menyediakan Projek

mkdir rest-api
cd rest-api
npm init -y
npm install express typescript @types/node @types/express ts-node-dev
npx tsc --init

Middleware untuk Pengendalian Ralat

// src/middlewares/ErrorHandler.ts
import { Request, Response, NextFunction } from 'express';

class ErrorHandler extends Error {
  statusCode: number;
  message: string;

  constructor(statusCode: number, message: string) {
    super();
    this.statusCode = statusCode;
    this.message = message;
  }
}

const handleError = (err: ErrorHandler, req: Request, res: Response, next: NextFunction) => {
  const { statusCode, message } = err;
  res.status(statusCode).json({
    status: 'error',
    statusCode,
    message,
  });
};

export { ErrorHandler, handleError };

Model Pengguna

// src/models/User.ts
export interface User {
  id: number;
  name: string;
  email: string;
}

Repositori Pengguna

// src/repository/UserRepository.ts
import { User } from '../models/User';

class UserRepository {
  private users: User[] = [];

  findAll(): User[] {
    return this.users;
  }

  findById(id: number): User | undefined {
    return this.users.find(user => user.id === id);
  }

  create(user: User): User {
    this.users.push(user);
    return user;
  }
}

export default new UserRepository();

Perkhidmatan Pengguna

// src/services/UserService.ts
import UserRepository from '../repository/UserRepository';
import { User } from '../models/User';
import { ErrorHandler } from '../middlewares/ErrorHandler';

class UserService {
  getAllUsers(): User[] {
    return UserRepository.findAll();
  }

  getUserById(id: number): User | undefined {
    const user = UserRepository.findById(id);
    if (!user) {
      throw new ErrorHandler(404, 'User not found');
    }
    return user;
  }

  createUser(user: User): User {
    const { error } = userSchema.validate(user);
    if (error) {
      throw new ErrorHandler(400, error.details[0].message);
    }
    return UserRepository.create(user);
  }
}

export default new UserService();

Pengesahan Pengguna

// src/validations/UserValidation.ts
import Joi from 'joi';

const userSchema = Joi.object({
  id: Joi.number().required(),
  name: Joi.string().required(),
  email: Joi.string().email().required(),
});

export { userSchema };

Pengawal Pengguna

// src/controllers/UserController.ts
import { Request, Response, NextFunction } from 'express';
import UserService from '../services/UserService';
import { ErrorHandler } from '../middlewares/ErrorHandler';

class UserController {
  getAllUsers(req: Request, res: Response, next: NextFunction) {
    try {
      const users = UserService.getAllUsers();
      res.json(users);
    } catch (error) {
      next(error);
    }
  }

  getUserById(req: Request, res: Response, next: NextFunction) {
    try {
      const user = UserService.getUserById(parseInt(req.params.id));
      res.json(user);
    } catch (error) {
      next(error);
    }
  }

  createUser(req: Request, res: Response, next: NextFunction) {
    try {
      const user = UserService.createUser(req.body);
      res.status(201).json(user);
    } catch (error) {
      next(error);
    }
  }
}

export default new UserController();

Laluan Pengguna

// src/routes/UserRouter.ts
import { Router } from 'express';
import UserController from '../controllers/UserController';

const router = Router();

router.get('/users', UserController.getAllUsers);
router.get('/users/:id', UserController.getUserById);
router.post('/users', UserController.createUser);

export default router;

Titik Kemasukan Permohonan

// src/app.ts
import express from 'express';
import UserRouter from './routes/UserRouter';
import { handleError } from './middlewares/ErrorHandler';

const app = express();

app.use(express.json());
app.use('/api', UserRouter);
app.use(handleError);

export default app;

Persediaan Pelayan

// src/server.ts
import app from './app';

const PORT = process.env.PORT || 3000;

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

Dengan menstrukturkan projek kami menggunakan prinsip TypeScript, Express.js, Joi dan OOP, kami mencapai pangkalan kod yang bersih dan boleh diselenggara. Perisian tengah pengendalian ralat tersuai menyediakan cara yang konsisten untuk mengurus ralat merentas aplikasi, manakala logik pengesahan memastikan integriti data. Persediaan ini boleh berfungsi sebagai asas yang kukuh untuk aplikasi yang lebih kompleks.

Kenalan
E-mel: luizcalaca@gmail.com
Instagram: https://www.instagram.com/luizcalaca
Linkedin: https://www.linkedin.com/in/luizcalaca/
Twitter: https://twitter.com/luizcalaca

Atas ialah kandungan terperinci Pengendalian ralat tersuai dalam API REST menggunakan TypeScript, Express.js, pengesahan Joi dan pengaturcaraan berorientasikan objek. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!