Crie uma API CRUD com MongoDB, Typescript, Express, Prisma e Zod

1
mkdir CRUD-API
2
cd CRUD-API

1
npm init -y
2
npm install prisma typescript ts-node @types/node --save-dev

1
 npx tsc --init

1
npx prisma

1
npx prisma init

1
npm install @prisma/client express zod

1
npm install @types/express nodemon --save-dev

1
{
2
  "name": "crud-api",
3
  "version": "1.0.0",
4
  "description": "",
5
  "main": "index.js",
6
  "scripts": {
7
    "test": "echo \"Error: no test specified\" && exit 1"
8
  },
9
  "keywords": [],
10
  "author": "",
11
  "license": "ISC",
12
  "devDependencies": {
13
    "@types/express": "^4.17.21",
14
    "@types/node": "^20.12.10",
15
    "nodemon": "^3.1.0",
16
    "prisma": "^5.13.0",
17
    "ts-node": "^10.9.2",
18
    "typescript": "^5.4.5"
19
  },
20
  "dependencies": {
21
    "@prisma/client": "^5.13.0",
22
    "express": "^4.19.2",
23
    "zod": "^3.23.7"
24
  }
25
}

1
├── CRUD-API 
2
│   ├── node_modules               
3
│   ├── Prisma
4
│   │ └── Schema.prisma
5
│   ├── src
6
│   ├── .gitignore
7
│   ├── package.json
8
│   ├── package-lock.json
9
│   └── tsconfig.json

1
import Express from 'express';
2
3
// Initiate express
4
const app = Express();
5
6
app.use(Express.json());
7
8
// Setup “hello world” endpoint
9
10
const port = process.env.PORT || 3000;
11
12
app.get('*', (req, res) => res.send('Hello World!'));
13
14
// Start the express server on the relevant port
15
app.listen(port, () => {
16
  console.log(`server is running on ${port}`);
17
});

1
"dev": "nodemon --watch ./src  --ext ts --exec 'ts-node ./src/app.ts'"

1
npm run dev

1
DATABASE_URL="mongodb+srv://<username>:<password>@<cluster-name>.xxxxx.mongodb.net/"

1
generator client {
2
  provider = "prisma-client-js"
3
}
4
5
datasource db {
6
  provider = "mongodb"
7
  url      = env("DATABASE_URL")
8
}

1
Operation    API route          HTTP method
2
Create User  /api/users         POST
3
Get Users    /api/users         GET
4
Fetch a User /api/users:userId  GET
5
Update a User/api/users:userId  PATCH
6
Delete a User/api/users:userId  DELETE

1
model User {
2
  id String @id @default(auto()) @map("_id") @db.ObjectId
3
  name String
4
  email String
5
  phoneNumber String
6
  gender String
7
}

1
npx prisma generate

1
import { PrismaClient } from '@prisma/client';
2
3
const prisma = new PrismaClient();
4
5
export default prisma;

1
📦 CRUD-API
2
┣ 📂 src
3
┃ ┣ 📂 routes
4
┃ ┣ 📂 controllers
5
┃ ┣ 📄 app.ts
6
┃ ┣ 📄 client.ts

1
import { Request, Response } from "express";
2
import prisma from "../client";
3
4
// Creating a user
5
export async function createUser(req: Request, res: Response) {
6
  try {
7
    const user = await prisma.user.create({
8
      data: req.body,
9
    });
10
11
    res.status(201).json({
12
      status: true,
13
      message: "User Successfully Created",
14
      data: user,
15
    });
16
  } catch (error) {
17
    res.status(500).json({
18
      status: false,
19
      message: 'server error'
20
    });
21
  }
22
}

1
// Get all Users
2
export async function getUsers(req: Request, res: Response) {
3
  const users = await prisma.user.findMany();
4
5
  res.json({
6
    status: true,
7
    message: "Users Successfully fetched",
8
    data: users,
9
  });
10
}
11
12
In the preceding code, the getUsers controller gets all users.
13
14
### getUser controller
15
The getUser controller handles GET requests for a single user.
16
17
Enter the following in the `user.route.ts` file.
18
// Get a single user
19
export async function getUser(req: Request, res: Response) {
20
  const { userid } = req.params;
21
  const user = await prisma.user.findFirst({
22
    where: {
23
      id: userid,
24
    },
25
  });
26
27
  res.json({
28
    status: true,
29
    message: "User Successfully fetched",
30
    data: user,
31
  });
32
}

1
// deleting a user
2
export async function deleteUser(req: Request, res: Response) {
3
  const { userid } = req.params;
4
5
  try {
6
    const user = await prisma.user.findFirst({
7
      where: {
8
        id: userid,
9
      },
10
    });
11
12
    if (!user) {
13
      return res.status(401).json({
14
        status: false,
15
        message: 'User not found',
16
      });
17
    }
18
    await prisma.user.delete({
19
      where: {
20
        id: userid,
21
      },
22
    }),
23
      res.json({
24
        status: true,
25
        message: 'User Successfully deleted',
26
      });
27
  } catch {
28
    res.status(501).json({
29
      status: false,
30
      message: 'server error',
31
    });
32
  }
33
}

1
// updating a single user
2
export async function updateUser(req: Request, res: Response) {
3
  try {
4
    const { userid } = req.params;
5
6
    const user = await prisma.user.findFirst({
7
      where: {
8
        id: userid,
9
      },
10
    });
11
12
    if (!user) {
13
      return res.status(401).json({
14
        status: false,
15
        message: 'User not found',
16
      });
17
    }
18
19
    const updatedUser = await prisma.user.update({
20
      where: {
21
        id: userid,
22
      },
23
      data: req.body,
24
    });
25
26
    res.json({
27
      status: true,
28
      message: 'User Successfully updated',
29
      data: updatedUser,
30
    });
31
  } catch (error) {
32
    console.log(error);
33
    res.status(500).json({
34
      status: false,
35
      message: 'server error',
36
    });
37
  }
38
}

1
import { Router } from 'express';
2
import userRoute from './user.route';
3
4
// Index
5
const indexRoute = Router();
6
7
indexRoute.get('', async (req, res) => {
8
  res.json({ message: 'Welcome User' });
9
});
10
11
indexRoute.use('/users', userRoute);
12
13
export default indexRoute;
14
15
Next, in user.routes.ts enter the following code:
16
import { Router } from 'express';
17
import {
18
  createUser,
19
  deleteUser,
20
  getUser,
21
  getUsers,
22
  updateUser,
23
} from '../controllers/user.controller';
24
25
// Users layout Route
26
const userRoute = Router();
27
28
userRoute.post('', createUser);
29
userRoute.get('', getUsers);
30
userRoute.get('/:userid', getUser);
31
userRoute.delete('/:userid', deleteUser);
32
userRoute.patch('/:userid', updateUser);
33
34
export default userRoute;

1
import { z } from 'zod';
2
3
export const createUserSchema = z
4
  .object({
5
    name: z.string().min(1),
6
    email: z.string().email(),
7
    phoneNumber: z.string().regex(/^\d+$/),
8
    gender: z.enum(['male', 'female', 'others']),
9
  })
10
  .strict(); //strict prevents the schema from validating payloads with properties not in the schema
11
12
export const updateUserSchema = createUserSchema.partial(); //creates a partial schema from createUserSchema where all properties are optional

1
import { NextFunction, Request, Response } from 'express';
2
import { ZodSchema } from 'zod';
3
4
// Validation middleware
5
export const validateSchema =
6
  (schema: ZodSchema) => (req: Request, res: Response, next: NextFunction) => {
7
    // parse request body 
8
    const { success, error } = schema.safeParse(req.body);
9
10
    // handle non-compliant request body
11
    if (!success) {
12
      return res.status(401).json({
13
        status: false,
14
        message: error.errors
15
          .map((t) => `${t.path[0] ?? ''}: ${t.message}`)
16
          .join(', '),
17
      });
18
    }
19
20
    next();
21
  };

1
import { Router } from 'express';
2
import {
3
  createUser,
4
  deleteUser,
5
  getUser,
6
  getUsers,
7
  updateUser,
8
} from '../controllers/user.controller';
9
import { validateSchema } from '../middlewares/validation.middleware';
10
import { createUserSchema, updateUserSchema } from '../schemas/user.schema';
11
12
// Users layout Route
13
const userRoute = Router();
14
15
userRoute.post('', validateSchema(createUserSchema), createUser);
16
userRoute.get('', getUsers);
17
userRoute.get('/:userid', getUser);
18
userRoute.delete('/:userid', deleteUser);
19
userRoute.patch('/:userid', validateSchema(updateUserSchema), updateUser);
20
21
export default userRoute;