Merge pull request Discorverly#194 from blegodwin/rest-crud

add restaurant module with CRUD operations and validation

Author: zakkiyyat

apps/api/src/app.ts

@@ -4,6 +4,7 @@ import { rateLimit } from 'express-rate-limit';
 import helmet from 'helmet';
 import morgan from 'morgan';
 import { authRouter } from './modules/auth/routes/auth.routes.js';
+import { restaurantRouter } from './modules/restaurants/routes/restaurant.routes.js';
 import { uploadsRouter } from './modules/uploads/uploads.routes.js';
 import { errorHandler } from './shared/middleware/error-handler.js';
 import { notFoundHandler } from './shared/middleware/not-found.js';
@@ -26,6 +27,7 @@ export function createApp(): Express {
   });
 
   app.use('/api/auth', authRouter);
+  app.use('/api/restaurants', restaurantRouter);
   app.use('/api/uploads', uploadsRouter);
 
   app.use(notFoundHandler);

apps/api/src/modules/restaurants/controllers/restaurant.controller.ts

@@ -0,0 +1,69 @@
+import type { NextFunction, Request, Response } from 'express';
+import { AppError } from '../../../shared/errors/app-error.js';
+import type { AuthenticatedRequest } from '../../../shared/types/express.js';
+import { restaurantService } from '../services/restaurant.service.js';
+import { createRestaurantSchema, updateRestaurantSchema } from '../validators/restaurant.validators.js';
+
+export const restaurantController = {
+  async create(req: AuthenticatedRequest, res: Response, next: NextFunction): Promise<void> {
+    try {
+      if (!req.user) throw AppError.unauthorized();
+      const data = createRestaurantSchema.parse(req.body);
+      const restaurant = await restaurantService.create(req.user.id, data);
+      res.status(201).json({ data: restaurant });
+    } catch (error) {
+      next(error);
+    }
+  },
+
+  async list(req: Request, res: Response, next: NextFunction): Promise<void> {
+    try {
+      const page = Math.max(1, Number(req.query['page']) || 1);
+      const limit = Math.min(50, Math.max(1, Number(req.query['limit']) || 20));
+      const { docs, total } = await restaurantService.list(page, limit);
+      res.status(200).json({ data: docs, meta: { page, limit, total } });
+    } catch (error) {
+      next(error);
+    }
+  },
+
+  async getById(req: Request, res: Response, next: NextFunction): Promise<void> {
+    try {
+      const restaurant = await restaurantService.getById(req.params['id']!);
+      res.status(200).json({ data: restaurant });
+    } catch (error) {
+      next(error);
+    }
+  },
+
+  async getOwn(req: AuthenticatedRequest, res: Response, next: NextFunction): Promise<void> {
+    try {
+      if (!req.user) throw AppError.unauthorized();
+      const restaurant = await restaurantService.getByOwner(req.user.id);
+      res.status(200).json({ data: restaurant });
+    } catch (error) {
+      next(error);
+    }
+  },
+
+  async update(req: AuthenticatedRequest, res: Response, next: NextFunction): Promise<void> {
+    try {
+      if (!req.user) throw AppError.unauthorized();
+      const data = updateRestaurantSchema.parse(req.body);
+      const restaurant = await restaurantService.update(req.params['id']!, req.user.id, data);
+      res.status(200).json({ data: restaurant });
+    } catch (error) {
+      next(error);
+    }
+  },
+
+  async delete(req: AuthenticatedRequest, res: Response, next: NextFunction): Promise<void> {
+    try {
+      if (!req.user) throw AppError.unauthorized();
+      await restaurantService.delete(req.params['id']!, req.user.id);
+      res.status(204).send();
+    } catch (error) {
+      next(error);
+    }
+  },
+};

apps/api/src/modules/restaurants/repositories/restaurant.model.ts

@@ -0,0 +1,38 @@
+import { Schema, model, type HydratedDocument, type InferSchemaType } from 'mongoose';
+
+const coordinatesSchema = new Schema(
+  {
+    lat: { type: Number, required: true },
+    lng: { type: Number, required: true },
+  },
+  { _id: false },
+);
+
+const addressSchema = new Schema(
+  {
+    street: { type: String, trim: true },
+    city: { type: String, required: true, trim: true },
+    country: { type: String, required: true, trim: true },
+    coordinates: { type: coordinatesSchema },
+  },
+  { _id: false },
+);
+
+const restaurantSchema = new Schema(
+  {
+    ownerId: { type: Schema.Types.ObjectId, required: true, ref: 'User', unique: true },
+    name: { type: String, required: true, trim: true, minlength: 2, maxlength: 100 },
+    description: { type: String, trim: true, maxlength: 500, default: '' },
+    address: { type: addressSchema, required: true },
+    cuisineTags: { type: [String], default: [] },
+    logoUrl: { type: String, default: null },
+    coverImageUrl: { type: String, default: null },
+    isActive: { type: Boolean, default: true },
+  },
+  { timestamps: true },
+);
+
+export type RestaurantAttributes = InferSchemaType<typeof restaurantSchema>;
+export type RestaurantDocument = HydratedDocument<RestaurantAttributes>;
+
+export const RestaurantModel = model('Restaurant', restaurantSchema);

apps/api/src/modules/restaurants/repositories/restaurant.repository.ts

@@ -0,0 +1,39 @@
+import { RestaurantModel, type RestaurantDocument } from './restaurant.model.js';
+import type { CreateRestaurantInput, UpdateRestaurantInput } from '../types/restaurant.types.js';
+
+export const restaurantRepository = {
+  async create(ownerId: string, data: CreateRestaurantInput): Promise<RestaurantDocument> {
+    return RestaurantModel.create({ ...data, ownerId });
+  },
+
+  async findById(id: string): Promise<RestaurantDocument | null> {
+    return RestaurantModel.findById(id);
+  },
+
+  async findActiveById(id: string): Promise<RestaurantDocument | null> {
+    return RestaurantModel.findOne({ _id: id, isActive: true });
+  },
+
+  async findByOwnerId(ownerId: string): Promise<RestaurantDocument | null> {
+    return RestaurantModel.findOne({ ownerId, isActive: true });
+  },
+
+  async listActive(page: number, limit: number): Promise<{ docs: RestaurantDocument[]; total: number }> {
+    const [docs, total] = await Promise.all([
+      RestaurantModel.find({ isActive: true })
+        .sort({ createdAt: -1 })
+        .skip((page - 1) * limit)
+        .limit(limit),
+      RestaurantModel.countDocuments({ isActive: true }),
+    ]);
+    return { docs, total };
+  },
+
+  async updateById(id: string, data: UpdateRestaurantInput): Promise<RestaurantDocument | null> {
+    return RestaurantModel.findByIdAndUpdate(id, { $set: data }, { new: true, runValidators: true });
+  },
+
+  async softDelete(id: string): Promise<RestaurantDocument | null> {
+    return RestaurantModel.findByIdAndUpdate(id, { $set: { isActive: false } }, { new: true });
+  },
+};

apps/api/src/modules/restaurants/routes/restaurant.routes.ts

@@ -0,0 +1,12 @@
+import { Router } from 'express';
+import { authenticate } from '../../auth/middleware/authenticate.js';
+import { restaurantController } from '../controllers/restaurant.controller.js';
+
+export const restaurantRouter = Router();
+
+restaurantRouter.post('/', authenticate, restaurantController.create);
+restaurantRouter.get('/', restaurantController.list);
+restaurantRouter.get('/me', authenticate, restaurantController.getOwn);
+restaurantRouter.get('/:id', restaurantController.getById);
+restaurantRouter.patch('/:id', authenticate, restaurantController.update);
+restaurantRouter.delete('/:id', authenticate, restaurantController.delete);

apps/api/src/modules/restaurants/services/restaurant.service.ts

@@ -0,0 +1,45 @@
+import { AppError } from '../../../shared/errors/app-error.js';
+import { restaurantRepository } from '../repositories/restaurant.repository.js';
+import type { CreateRestaurantInput, UpdateRestaurantInput } from '../types/restaurant.types.js';
+
+export const restaurantService = {
+  async create(ownerId: string, data: CreateRestaurantInput) {
+    const existing = await restaurantRepository.findByOwnerId(ownerId);
+    if (existing) throw AppError.conflict('You already own a restaurant');
+    return restaurantRepository.create(ownerId, data);
+  },
+
+  async getById(id: string) {
+    const restaurant = await restaurantRepository.findActiveById(id);
+    if (!restaurant) throw AppError.notFound('Restaurant not found');
+    return restaurant;
+  },
+
+  async getByOwner(ownerId: string) {
+    const restaurant = await restaurantRepository.findByOwnerId(ownerId);
+    if (!restaurant) throw AppError.notFound('You do not own a restaurant');
+    return restaurant;
+  },
+
+  async list(page: number, limit: number) {
+    return restaurantRepository.listActive(page, limit);
+  },
+
+  async update(id: string, ownerId: string, data: UpdateRestaurantInput) {
+    const restaurant = await restaurantRepository.findById(id);
+    if (!restaurant) throw AppError.notFound('Restaurant not found');
+    if (restaurant.ownerId.toString() !== ownerId) {
+      throw new AppError('You are not the owner of this restaurant', 403);
+    }
+    return restaurantRepository.updateById(id, data);
+  },
+
+  async delete(id: string, ownerId: string) {
+    const restaurant = await restaurantRepository.findById(id);
+    if (!restaurant) throw AppError.notFound('Restaurant not found');
+    if (restaurant.ownerId.toString() !== ownerId) {
+      throw new AppError('You are not the owner of this restaurant', 403);
+    }
+    return restaurantRepository.softDelete(id);
+  },
+};

apps/api/src/modules/restaurants/types/restaurant.types.ts

@@ -0,0 +1,27 @@
+export interface RestaurantAddress {
+  street?: string;
+  city: string;
+  country: string;
+  coordinates?: {
+    lat: number;
+    lng: number;
+  };
+}
+
+export interface CreateRestaurantInput {
+  name: string;
+  description?: string;
+  address: RestaurantAddress;
+  cuisineTags?: string[];
+  logoUrl?: string | null;
+  coverImageUrl?: string | null;
+}
+
+export interface UpdateRestaurantInput {
+  name?: string;
+  description?: string;
+  address?: Partial<RestaurantAddress>;
+  cuisineTags?: string[];
+  logoUrl?: string | null;
+  coverImageUrl?: string | null;
+}

apps/api/src/modules/restaurants/validators/restaurant.validators.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { CUISINE_TAGS } from '@discoverly/shared';
+
+const coordinatesSchema = z.object({
+  lat: z.number().finite(),
+  lng: z.number().finite(),
+});
+
+const addressSchema = z.object({
+  street: z.string().trim().optional(),
+  city: z.string().trim().min(1, 'City is required'),
+  country: z.string().trim().min(1, 'Country is required'),
+  coordinates: coordinatesSchema.optional(),
+});
+
+export const createRestaurantSchema = z.object({
+  name: z.string().trim().min(2).max(100),
+  description: z.string().trim().max(500).optional(),
+  address: addressSchema,
+  cuisineTags: z.array(z.enum(CUISINE_TAGS)).max(5).optional(),
+  logoUrl: z.string().url().nullable().optional(),
+  coverImageUrl: z.string().url().nullable().optional(),
+});
+
+export const updateRestaurantSchema = z.object({
+  name: z.string().trim().min(2).max(100).optional(),
+  description: z.string().trim().max(500).optional(),
+  address: addressSchema.partial().optional(),
+  cuisineTags: z.array(z.enum(CUISINE_TAGS)).max(5).optional(),
+  logoUrl: z.string().url().nullable().optional(),
+  coverImageUrl: z.string().url().nullable().optional(),
+});