feat: validate incoming request data for available schemas.

package.json

@@ -77,7 +77,8 @@
 		"mongoose": "^7.5.1",
 		"multer": "^1.4.5-lts.1",
 		"uuid": "^9.0.1",
-		"validator": "^13.11.0"
+		"validator": "^13.11.0",
+		"zod": "^3.23.8"
 	},
 	"devDependencies": {
 		"@types/bcrypt": "^5.0.1",

src/validators/category.ts

@@ -0,0 +1,38 @@
+import type { NextFunction, Request, Response } from "express"
+import { HTTP } from "src/common/constants"
+import { z } from "zod"
+
+export const categorySchema = z.object({
+	id: z.string().optional(),
+	name: z
+		.string({ required_error: "name is required!!" })
+		.trim()
+		.min(2, { message: "name must be longer than 2 letters" }),
+	slug: z.string().trim().optional(), // probably we generate this
+	description: z
+		.string({ required_error: "description is required!!" })
+		.trim()
+		.min(5, { message: "description must be more than 5 letters long" }),
+	noOfProducts: z.number({ coerce: true }).default(0),
+	created_at: z.date().optional(),
+	updated_at: z.date().optional(),
+})
+
+export const validateCategory = (req: Request, res: Response, next: NextFunction) => {
+	const { success, error, data } = categorySchema.safeParse(req.body)
+
+	if (!success) {
+		const errors = error.flatten().fieldErrors
+		// it's not a bad request if we can't process the data.
+		// or should we use "400" (BAD_REQUEST) instead ??
+		return res.status(HTTP.UNPROCESSABLE_ENTITY).json({
+			status: success,
+			// only send one error at a time,
+			// should we send a list of errors ??
+			message: Object.values(errors).flat()[0],
+		})
+	}
+
+	req.body = data
+	next()
+}

src/validators/customers.ts

@@ -0,0 +1,36 @@
+import type { NextFunction, Request, Response } from "express"
+import { HTTP } from "src/common/constants"
+import { z } from "zod"
+
+export const customerSchema = z.object({
+	id: z.string().optional(),
+	name: z
+		.string({ required_error: "name is required!!" })
+		.trim()
+		.min(2, { message: "name must be longer than 2 letters" }),
+	email: z.string().email(),
+	avatar: z
+		.string({ required_error: "avatar is required!!" })
+		.trim()
+		.min(5, { message: '"avatar" image must be more than 5 letters long' }),
+	created_at: z.date().optional(),
+})
+
+export const validateCustomer = (req: Request, res: Response, next: NextFunction) => {
+	const { success, error, data } = customerSchema.safeParse(req.body)
+
+	if (!success) {
+		const errors = error.flatten().fieldErrors
+		// it's not a bad request if we can't process the data.
+		// or should we use "400" (BAD_REQUEST) instead ??
+		return res.status(HTTP.UNPROCESSABLE_ENTITY).json({
+			status: success,
+			// only send one error at a time,
+			// should we send a list of errors ??
+			message: Object.values(errors).flat()[0],
+		})
+	}
+
+	req.body = data
+	next()
+}

src/validators/product.ts

@@ -0,0 +1,47 @@
+import type { NextFunction, Request, Response } from "express"
+import { HTTP } from "src/common/constants"
+import { z } from "zod"
+
+export const customerSchema = z.object({
+	id: z.string().optional(),
+	name: z
+		.string({ required_error: "name is required!!" })
+		.trim()
+		.min(2, { message: "name must be longer than 2 letters" }),
+	slug: z.string().optional(),
+	description: z
+		.string({ required_error: "description is required!!" })
+		.trim()
+		.min(5, { message: '"description" image must be more than 5 letters long' }),
+	price: z.number({ coerce: true }).min(0.1),
+	quantity: z.number({ coerce: true }).default(0),
+	assets: z.array(z.string(), {
+		invalid_type_error: "assets must be an array of string",
+		required_error: "assets is required",
+	}),
+	categories: z
+		.string({ required_error: "product must belong to a category, category id is required" })
+		.min(7),
+	variants: z.string().optional(),
+	created_at: z.date().optional(),
+	updated_at: z.date().optional(),
+})
+
+export const validateProduct = (req: Request, res: Response, next: NextFunction) => {
+	const { success, error, data } = customerSchema.safeParse(req.body)
+
+	if (!success) {
+		const errors = error.flatten().fieldErrors
+		// it's not a bad request if we can't process the data.
+		// or should we use "400" (BAD_REQUEST) instead ??
+		return res.status(HTTP.UNPROCESSABLE_ENTITY).json({
+			status: success,
+			// only send one error at a time,
+			// should we send a list of errors ??
+			message: Object.values(errors).flat()[0],
+		})
+	}
+
+	req.body = data
+	next()
+}

src/validators/user.ts

@@ -0,0 +1,38 @@
+import type { NextFunction, Request, Response } from "express"
+import { HTTP } from "src/common/constants"
+import { z } from "zod"
+
+export const userSchema = z.object({
+	id: z.string().optional(),
+	name: z
+		.string({ required_error: "name is required!!" })
+		.trim()
+		.min(2, { message: "name must be longer than 2 letters" }),
+	email: z.string().email(),
+	password: z
+		.string({ required_error: "password is required!!" })
+		.min(6, { message: '"password" must be more than 6 characters' }),
+	apiKey: z.string({ required_error: "apiKey is required" }).min(5),
+	avatar: z.string({ required_error: "avatar is required" }),
+	created_at: z.date().optional(),
+	updated_at: z.date().optional(),
+})
+
+export const validateUser = (req: Request, res: Response, next: NextFunction) => {
+	const { success, error, data } = userSchema.safeParse(req.body)
+
+	if (!success) {
+		const errors = error.flatten().fieldErrors
+		// it's not a bad request if we can't process the data.
+		// or should we use "400" (BAD_REQUEST) instead ??
+		return res.status(HTTP.UNPROCESSABLE_ENTITY).json({
+			status: success,
+			// only send one error at a time,
+			// should we send a list of errors ??
+			message: Object.values(errors).flat()[0],
+		})
+	}
+
+	req.body = data
+	next()
+}

src/validators/variant.ts

@@ -0,0 +1,43 @@
+import type { NextFunction, Request, Response } from "express"
+import { HTTP } from "src/common/constants"
+import { z } from "zod"
+
+const variantOption = z.object({
+	id: z.string(),
+	name: z.string(),
+	price: z.number().optional(),
+	quantity: z.number().optional(),
+	image_url: z.string().optional(),
+	created_at: z.date().optional(),
+	updated_at: z.date().optional(),
+})
+
+export const variantSchema = z.object({
+	id: z.string().optional(),
+	name: z
+		.string({ required_error: "name is required!!" })
+		.trim()
+		.min(2, { message: "name must be longer than 2 letters" }),
+	options: z.array(variantOption).optional(), // should this be optional ??
+	created_at: z.date().optional(),
+	updated_at: z.date().optional(),
+})
+
+export const validateVariant = (req: Request, res: Response, next: NextFunction) => {
+	const { success, error, data } = variantSchema.safeParse(req.body)
+
+	if (!success) {
+		const errors = error.flatten().fieldErrors
+		// it's not a bad request if we can't process the data.
+		// or should we use "400" (BAD_REQUEST) instead ??
+		return res.status(HTTP.UNPROCESSABLE_ENTITY).json({
+			status: success,
+			// only send one error at a time,
+			// should we send a list of errors ??
+			message: Object.values(errors).flat()[0],
+		})
+	}
+
+	req.body = data
+	next()
+}