change entity names

src/modules/foods/controllers/category.controller.ts

@@ -1,89 +0,0 @@
-import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
-import { CategoryService } from '../providers/category.service';
-import { CreateCategoryDto } from '../dto/create-category.dto';
-import { UpdateCategoryDto } from '../dto/update-category.dto';
-import {
-  ApiTags,
-  ApiOperation,
-  ApiCreatedResponse,
-  ApiOkResponse,
-  ApiNotFoundResponse,
-  ApiParam,
-  ApiBody,
-  ApiBearerAuth,
-  ApiHeader,
-} from '@nestjs/swagger';
-import { AdminAuthGuard } from 'src/modules/auth/guards/adminAuth.guard';
-import { UseGuards } from '@nestjs/common';
-import { RestId } from 'src/common/decorators';
-import { Permission } from 'src/common/enums/permission.enum';
-import { Permissions } from 'src/common/decorators/permissions.decorator';
-import { API_HEADER_SLUG } from 'src/common/constants';
-
-@ApiTags('category')
-@Controller()
-export class CategoryController {
-  constructor(private readonly categoryService: CategoryService) { }
-
-  @Get('public/categories/restaurant/:slug')
-  @ApiOperation({ summary: 'Get all categories by restaurant slug' })
-  @ApiHeader(API_HEADER_SLUG)
-  @ApiParam({ name: 'slug', required: true, description: 'Restaurant Slug' })
-  @ApiOkResponse({ description: 'List of all categories for the restaurant' })
-  findAllByRestaurant(@Param('slug') slug: string) {
-    return this.categoryService.findAllByRestaurant(slug);
-  }
-
-  /*** Admin ***/
-
-  @ApiOperation({ summary: 'Create category' })
-  @ApiBody({ type: CreateCategoryDto })
-  @Permissions(Permission.MANAGE_CATEGORIES)
-  @UseGuards(AdminAuthGuard)
-  @ApiBearerAuth()
-  @Post('admin/categories')
-  create(@Body() dto: CreateCategoryDto, @RestId() restId: string) {
-    return this.categoryService.create(restId, dto);
-  }
-  @Permissions(Permission.MANAGE_CATEGORIES)
-  @ApiOperation({ summary: 'my restaurant categories' })
-  @UseGuards(AdminAuthGuard)
-  @ApiBearerAuth()
-  @Get('admin/categories') 
-  findAll(@RestId() restId: string) {
-    return this.categoryService.findAllByRestaurantId(restId);
-  } 
-
-  @Permissions(Permission.MANAGE_CATEGORIES)
-  @UseGuards(AdminAuthGuard)
-  @ApiBearerAuth()
-  @Get('admin/categories/:id')
-  @ApiOperation({ summary: 'Get category' })
-  @ApiParam({ name: 'id', required: true, type: String })
-  findOne(@Param('id') id: string, @RestId() restId: string) {
-    return this.categoryService.findOne(restId, id);
-  }
-
-  @UseGuards(AdminAuthGuard)
-  @ApiBearerAuth()
-  @Permissions(Permission.MANAGE_CATEGORIES)
-  @Patch('admin/categories/:id')
-  @ApiOperation({ summary: 'Update category' })
-  @ApiParam({ name: 'id' })
-  @ApiBody({ type: UpdateCategoryDto })
-  update(@Param('id') id: string, @Body() dto: UpdateCategoryDto, @RestId() restId: string) {
-    return this.categoryService.update(restId, id, dto);
-  }
-
-  @UseGuards(AdminAuthGuard)
-  @ApiBearerAuth()
-  @Permissions(Permission.MANAGE_CATEGORIES)
-  @Delete('admin/categories/:id')
-  @ApiOperation({ summary: 'Delete category' })
-  @ApiParam({ name: 'id' })
-  @ApiOkResponse({ description: 'Deleted' })
-  remove(@Param('id') id: string, @RestId() restId: string) {
-    return this.categoryService.remove(restId, id);
-  }
-
-}

src/modules/foods/controllers/food.controller.ts

@@ -1,123 +0,0 @@
-import { Controller, Get, Post, Body, Patch, Param, Delete, Query, UseGuards } from '@nestjs/common';
-import { FoodService } from '../providers/food.service';
-import { CreateFoodDto } from '../dto/create-food.dto';
-import { UpdateFoodDto } from '../dto/update-food.dto';
-import { FindFoodsDto } from '../dto/find-foods.dto';
-import {
-  ApiTags,
-  ApiOperation,
-  ApiQuery,
-  ApiBody,
-  ApiParam,
-  ApiBearerAuth,
-  ApiHeader,
-} from '@nestjs/swagger';
-import { AdminAuthGuard } from 'src/modules/auth/guards/adminAuth.guard';
-import { RestId, UserId } from 'src/common/decorators';
-import { AuthGuard } from 'src/modules/auth/guards/auth.guard';
-import { OptionalAuthGuard } from 'src/modules/auth/guards/optinalAuth.guard';
-import { API_HEADER_SLUG } from 'src/common/constants';
-import { Permission } from 'src/common/enums/permission.enum';
-import { Permissions } from 'src/common/decorators/permissions.decorator';
-
-@ApiTags('foods')
-@Controller()
-export class FoodController {
-  constructor(private readonly foodsService: FoodService) { }
-
-  @Get('public/foods/restaurant/:slug')
-  @ApiOperation({ summary: 'Get all foods by restaurant slug' })
-  @ApiHeader(API_HEADER_SLUG)
-  @ApiParam({ name: 'slug', required: true, description: 'Restaurant Slug' })
-  findAllByRestaurant(@Param('slug') slug: string) {
-    return this.foodsService.findByWeekDateAndMealType(slug);
-  }
-
-  @Get('public/foods/:foodId')
-  @UseGuards(OptionalAuthGuard)
-  @ApiHeader(API_HEADER_SLUG)
-  @ApiBearerAuth()
-  @ApiOperation({ summary: 'Get a food by id' })
-  @ApiParam({ name: 'foodId', required: true })
-  findPublicFoodById(@Param('foodId') foodId: string, @UserId() userId?: string): Promise<any> {
-    const a = this.foodsService.findPublicById(foodId, userId);
-    return a;
-  }
-
-  @Post('public/foods/favorite/:foodId')
-  @UseGuards(AuthGuard)
-  @ApiHeader(API_HEADER_SLUG)
-  @ApiBearerAuth()
-  @ApiOperation({ summary: 'toggle a food as favorite' })
-  @ApiParam({ name: 'foodId', required: true })
-  setAsFavorute(@Param('foodId') foodId: string, @UserId() userId: string) {
-    return this.foodsService.toggleFavorite(userId, foodId);
-  }
-
-  @Get('public/foods/favorite')
-  @UseGuards(AuthGuard)
-  @ApiHeader(API_HEADER_SLUG)
-  @ApiBearerAuth()
-  @ApiOperation({ summary: 'get my favorites' })
-  getMyFavorites(@UserId() userId: string, @RestId() restId: string) {
-    return this.foodsService.getMyFavorites(userId, restId);
-  }
-
-  /* ---------------------------------- Admin ---------------------------------- */
-  @UseGuards(AdminAuthGuard)
-  @ApiBearerAuth()
-  @Permissions(Permission.MANAGE_FOODS)
-  @Post('admin/foods')
-  @ApiOperation({ summary: 'Create a new food' })
-  @ApiBody({ type: CreateFoodDto })
-  create(@Body() createFoodDto: CreateFoodDto, @RestId() restId: string) {
-    return this.foodsService.create(restId, createFoodDto);
-  }
-
-  @UseGuards(AdminAuthGuard)
-  @ApiBearerAuth()
-  @Permissions(Permission.MANAGE_FOODS)
-  @Get('admin/foods')
-  @ApiOperation({ summary: 'Get a paginated list of foods' })
-  @ApiQuery({ name: 'page', required: false, type: Number })
-  @ApiQuery({ name: 'limit', required: false, type: Number })
-  @ApiQuery({ name: 'search', required: false, type: String })
-  @ApiQuery({ name: 'orderBy', required: false, type: String })
-  @ApiQuery({ name: 'order', required: false, enum: ['asc', 'desc'] })
-  @ApiQuery({ name: 'categoryId', required: false, type: String })
-  @ApiQuery({ name: 'isActive', required: false, type: Boolean })
-  async findAll(@Query() dto: FindFoodsDto, @RestId() restId: string) {
-    const result = await this.foodsService.findAll(restId, dto);
-    return result;
-  }
-
-  @UseGuards(AdminAuthGuard)
-  @ApiBearerAuth()
-  @Permissions(Permission.MANAGE_FOODS)
-  @Get('admin/foods/:id')
-  @ApiOperation({ summary: 'Get a food by id' })
-  @ApiParam({ name: 'id', required: true })
-  findById(@Param('id') id: string, @RestId() restId: string) {
-    return this.foodsService.findAdminById(restId, id);
-  }
-
-  @UseGuards(AdminAuthGuard)
-  @ApiBearerAuth()
-  @Permissions(Permission.MANAGE_FOODS)
-  @Patch('admin/foods/:id')
-  @ApiOperation({ summary: 'Update a food' })
-  @ApiParam({ name: 'id', required: true })
-  @ApiBody({ type: UpdateFoodDto })
-  update(@Param('id') id: string, @Body() updateFoodDto: UpdateFoodDto, @RestId() restId: string) {
-    return this.foodsService.update(restId, id, updateFoodDto);
-  }
-  @UseGuards(AdminAuthGuard)
-  @ApiBearerAuth()
-  @Permissions(Permission.MANAGE_FOODS)
-  @Delete('admin/foods/:id')
-  @ApiOperation({ summary: 'Delete (soft) a food' })
-  @ApiParam({ name: 'id', required: true })
-  remove(@Param('id') id: string, @RestId() restId: string) {
-    return this.foodsService.remove(restId, id);
-  }
-}

src/modules/foods/crone/food.crone.ts

@@ -1,45 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { Cron } from '@nestjs/schedule';
-import { EntityManager } from '@mikro-orm/postgresql';
-import { Inventory } from '../../inventory/entities/inventory.entity';
-
-@Injectable()
-export class FoodStockCrone {
-  private readonly logger = new Logger(FoodStockCrone.name);
-
-  constructor(private readonly em: EntityManager) {}
-
-  // run every day at 00:03
-  @Cron('3 0 * * *', {
-    name: 'resetAvailableStock',
-    timeZone: 'UTC',
-  })
-  async handleCron() {
-    try {
-      this.logger.debug('Starting daily inventory reset (availableStock = totalStock)');
-
-      const inventories = await this.em.find(Inventory, {});
-      if (!inventories || inventories.length === 0) {
-        this.logger.debug('No inventory records found to reset');
-        return;
-      }
-
-      this.logger.log(`Resetting available stock for ${inventories.length} inventory records`);
-
-      await this.em.transactional(async em => {
-        for (const inv of inventories) {
-          // reload inside transaction to avoid concurrency issues
-          const record = await em.findOne(Inventory, { id: inv.id });
-          if (!record) continue;
-          record.availableStock = record.totalStock;
-          em.persist(record);
-        }
-        await em.flush();
-      });
-
-      this.logger.log('Daily inventory reset completed');
-    } catch (err) {
-      this.logger.error(`FoodStockCrone failed: ${err?.message}`, err);
-    }
-  }
-}

src/modules/foods/dto/create-category.dto.ts

@@ -1,27 +0,0 @@
-import { IsString, IsOptional, IsBoolean, IsInt, Min } from 'class-validator';
-import { ApiPropertyOptional } from '@nestjs/swagger';
-import { Type } from 'class-transformer';
-
-export class CreateCategoryDto {
-  @IsString()
-  @ApiPropertyOptional({ example: 'ایرانی' })
-  title!: string;
-
-  @IsOptional()
-  @IsBoolean()
-  @Type(() => Boolean)
-  @ApiPropertyOptional({ example: true })
-  isActive?: boolean;
-
-  @IsOptional()
-  @IsString()
-  @ApiPropertyOptional({ example: 'https://cdn.example.com/avatar.png' })
-  avatarUrl?: string;
-
-  @IsOptional()
-  @IsInt()
-  @Min(0)
-  @Type(() => Number)
-  @ApiPropertyOptional({ example: 1 })
-  order?: number;
-}

src/modules/foods/dto/create-food.dto.ts

@@ -1,85 +0,0 @@
-import { Type } from 'class-transformer';
-import {
-  ArrayUnique,
-  IsArray,
-  IsBoolean,
-  IsEnum,
-  IsInt,
-  IsNotEmpty,
-  IsNumber,
-  IsOptional,
-  IsString,
-  Max,
-  Min,
-} from 'class-validator';
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-
-export class CreateFoodDto {
-  @IsNotEmpty()
-  @IsString()
-  @ApiProperty()
-  categoryId: string;
-
-  @IsOptional()
-  @IsString()
-  @ApiPropertyOptional({ example: 'قرمه سبزی' })
-  title?: string;
-
-  @IsOptional()
-  @IsString()
-  @ApiPropertyOptional({ example: 'توضیحات غذا' })
-  desc?: string;
-
-  @IsOptional()
-  @IsArray()
-  @IsString({ each: true })
-  @ApiPropertyOptional({ type: [String] })
-  content?: string[];
-
-  @IsOptional()
-  @IsNumber()
-  @Min(0)
-  @Type(() => Number)
-  @ApiPropertyOptional({ example: 120000 })
-  price?: number;
-
-  @IsOptional()
-  @IsBoolean()
-  @ApiPropertyOptional({ example: true })
-  @Type(() => Boolean)
-  isActive?: boolean;
-
-  @IsOptional()
-  @IsArray()
-  @IsString({ each: true })
-  @ApiPropertyOptional({ type: [String] })
-  images?: string[];
-
-  @IsOptional()
-  @IsNumber()
-  @Min(0)
-  @Type(() => Number)
-  @ApiPropertyOptional({ example: 0 })
-  discount?: number;
-
-  @IsOptional()
-  @IsNumber()
-  @Min(0)
-  @Type(() => Number)
-  @ApiProperty({ example: 50 })
-  dailyStock: number;
-
-  @IsOptional()
-  @IsBoolean()
-  @ApiPropertyOptional({ example: false })
-  @Type(() => Boolean)
-  isSpecialOffer?: boolean;
-
-  @IsOptional()
-  @IsInt()
-  @Min(0)
-  @Type(() => Number)
-  @ApiPropertyOptional({ example: 1 })
-  order?: number;
-
-}

src/modules/foods/dto/find-foods.dto.ts

@@ -1,43 +0,0 @@
-import { IsOptional, IsNumber, IsString, IsIn, IsBoolean } from 'class-validator';
-import { ApiPropertyOptional } from '@nestjs/swagger';
-import { Type } from 'class-transformer';
-
-export class FindFoodsDto {
-  @IsOptional()
-  @IsNumber()
-  @Type(() => Number)
-  @ApiPropertyOptional({ example: 1 })
-  page?: number;
-
-  @IsOptional()
-  @IsNumber()
-  @Type(() => Number)
-  @ApiPropertyOptional({ example: 10 })
-  limit?: number;
-
-  @IsOptional()
-  @IsString()
-  @ApiPropertyOptional()
-  search?: string;
-
-  @IsOptional()
-  @IsString()
-  @ApiPropertyOptional({ example: 'createdAt' })
-  orderBy?: string;
-
-  @IsOptional()
-  @IsIn(['asc', 'desc'])
-  @ApiPropertyOptional({ example: 'desc' })
-  order?: 'asc' | 'desc';
-
-  @IsOptional()
-  @IsString()
-  @ApiPropertyOptional()
-  categoryId?: string;
-
-  @IsOptional()
-  @IsBoolean()
-  @Type(() => Boolean)
-  @ApiPropertyOptional({ example: true })
-  isActive?: boolean;
-}

src/modules/foods/dto/update-category.dto.ts

@@ -1,4 +0,0 @@
-import { PartialType } from '@nestjs/swagger';
-import { CreateCategoryDto } from './create-category.dto';
-
-export class UpdateCategoryDto extends PartialType(CreateCategoryDto) {}

src/modules/foods/dto/update-food.dto.ts

@@ -1,4 +0,0 @@
-import { PartialType } from '@nestjs/swagger';
-import { CreateFoodDto } from './create-food.dto';
-
-export class UpdateFoodDto extends PartialType(CreateFoodDto) {}

src/modules/foods/entities/category.entity.ts

@@ -1,27 +0,0 @@
-import { Entity, Index, Property, Collection, OneToMany, ManyToOne } from '@mikro-orm/core';
-import { Food } from './food.entity';
-import { BaseEntity } from '../../../common/entities/base.entity';
-import { Restaurant } from 'src/modules/restaurants/entities/restaurant.entity';
-
-@Entity({ tableName: 'categories' })
-@Index({ properties: ['restaurant', 'isActive'] })
-@Index({ properties: ['isActive'] })
-export class Category extends BaseEntity {
-  @Property()
-  title!: string;
-
-  @OneToMany(() => Food, food => food.category)
-  foods = new Collection<Food>(this);
-
-  @Property({ default: true })
-  isActive: boolean = true;
-
-  @ManyToOne(() => Restaurant)
-  restaurant!: Restaurant;
-
-  @Property({ nullable: true })
-  avatarUrl?: string;
-
-  @Property({ type: 'int', nullable: true })
-  order?: number;
-}

src/modules/foods/entities/favorite.entity.ts

@@ -1,14 +1,14 @@
 import { Entity, ManyToOne, Unique } from '@mikro-orm/core';
 import { BaseEntity } from '../../../common/entities/base.entity';
 import { User } from '../../users/entities/user.entity';
-import { Food } from '../../foods/entities/food.entity';
+import { Product } from '../../products/entities/product.entity';
 
 @Entity({ tableName: 'favorites' })
-@Unique({ properties: ['user', 'food'] })
+@Unique({ properties: ['user', 'product'] })
 export class Favorite extends BaseEntity {
     @ManyToOne(() => User)
     user: User;
 
-    @ManyToOne(() => Food)
-    food: Food;
+    @ManyToOne(() => Product)
+    product: Product;
 }

src/modules/foods/entities/food.entity.ts

@@ -1,32 +1,32 @@
 import { Cascade, Collection, Entity, Index, ManyToOne, OneToMany, Property, OneToOne } from '@mikro-orm/core';
 import { Category } from './category.entity';
 import { BaseEntity } from '../../../common/entities/base.entity';
-import { Restaurant } from '../../../modules/restaurants/entities/restaurant.entity';
+import { Shop } from '../../../modules/shops/entities/shop.entity';
 import { Review } from 'src/modules/review/entities/review.entity';
 import { Inventory } from 'src/modules/inventory/entities/inventory.entity';
 import { Favorite } from './favorite.entity';
 
-@Entity({ tableName: 'foods' })
-@Index({ properties: ['restaurant', 'isActive'] })
+@Entity({ tableName: 'products' })
+@Index({ properties: ['shop', 'isActive'] })
 @Index({ properties: ['category', 'isActive'] })
 @Index({ properties: ['isActive'] })
-export class Food extends BaseEntity {
-  @ManyToOne(() => Restaurant)
-  restaurant: Restaurant;
+export class Product extends BaseEntity {
+  @ManyToOne(() => Shop)
+  shop: Shop;
 
   @ManyToOne(() => Category)
   category: Category;
 
-  @OneToMany(() => Review, review => review.food, { cascade: [Cascade.ALL], orphanRemoval: true })
+  @OneToMany(() => Review, review => review.product, { cascade: [Cascade.ALL], orphanRemoval: true })
   reviews = new Collection<Review>(this);
 
   @OneToOne(() => Inventory, {
-    mappedBy: 'food',
+    mappedBy: 'product',
     nullable: true,
   })
   inventory?: Inventory;
 
-  @OneToMany(() => Favorite, favorite => favorite.food)
+  @OneToMany(() => Favorite, favorite => favorite.product)
   favorites = new Collection<Favorite>(this);
 
   @Property({ nullable: true })

src/modules/foods/food.module.ts

@@ -1,15 +1,15 @@
 import { Module } from '@nestjs/common';
-import { FoodService } from './providers/food.service';
-import { FoodStockCrone } from './crone/food.crone';
-import { FoodController } from './controllers/food.controller';
+import { ProductService } from './providers/product.service';
+import { ProductStockCrone } from './crone/product.crone';
+import { ProductController } from './controllers/product.controller';
 import { CategoryController } from './controllers/category.controller';
 import { CategoryService } from './providers/category.service';
-import { FoodRepository } from './repositories/food.repository';
+import { ProductRepository } from './repositories/product.repository';
 import { CategoryRepository } from './repositories/category.repository';
 import { MikroOrmModule } from '@mikro-orm/nestjs';
 import { Category } from './entities/category.entity';
-import { Food } from './entities/food.entity';
-import { RestaurantsModule } from '../restaurants/restaurants.module';
+import { Product } from './entities/product.entity';
+import { ShopsModule } from '../shops/shops.module';
 import { AuthModule } from '../auth/auth.module';
 import { JwtModule } from '@nestjs/jwt';
 import { UtilsModule } from '../utils/utils.module';
@@ -17,14 +17,14 @@ import { Favorite } from './entities/favorite.entity';
 
 @Module({
   imports: [
-    MikroOrmModule.forFeature([Food, Category, Favorite]),
-    RestaurantsModule,
+    MikroOrmModule.forFeature([Product, Category, Favorite]),
+    ShopsModule,
     AuthModule,
     JwtModule,
     UtilsModule,
   ],
-  controllers: [FoodController, CategoryController],
-  providers: [FoodService, CategoryService, FoodRepository, CategoryRepository, FoodStockCrone],
-  exports: [FoodRepository, CategoryRepository],
+  controllers: [ProductController, CategoryController],
+  providers: [ProductService, CategoryService, ProductRepository, CategoryRepository, ProductStockCrone],
+  exports: [ProductRepository, CategoryRepository],
 })
-export class FoodModule {}
+export class ProductModule {}

src/modules/foods/interface/food.interface.ts

@@ -1,6 +0,0 @@
-export enum MealType {
-  BREAKFAST = 'breakfast',
-  LUNCH = 'lunch',
-  DINNER = 'dinner',
-  SNACK = 'snack',
-}

src/modules/foods/providers/category.service.ts

@@ -1,81 +0,0 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
-import { CreateCategoryDto } from '../dto/create-category.dto';
-import { UpdateCategoryDto } from '../dto/update-category.dto';
-import { CategoryRepository } from '../repositories/category.repository';
-import { EntityManager } from '@mikro-orm/postgresql';
-import { RequiredEntityData } from '@mikro-orm/core';
-import { Category } from '../entities/category.entity';
-import { CategoryMessage, RestMessage } from 'src/common/enums/message.enum';
-import { Restaurant } from 'src/modules/restaurants/entities/restaurant.entity';
-
-@Injectable()
-export class CategoryService {
-  constructor(
-    private readonly categoryRepository: CategoryRepository,
-    private readonly em: EntityManager,
-  ) { }
-
-  async create(restId: string, dto: CreateCategoryDto): Promise<Category> {
-    const restaurant = await this.em.findOne(Restaurant, { id: restId });
-    if (!restaurant) {
-      throw new NotFoundException(RestMessage.NOT_FOUND);
-    }
-    const data: RequiredEntityData<Category> = {
-      title: dto.title,
-      isActive: dto.isActive ?? true,
-      restaurant: restaurant,
-      avatarUrl: dto.avatarUrl,
-    };
-
-    const category = this.categoryRepository.create(data);
-    await this.em.persistAndFlush(category);
-    return category;
-  }
-
-  async findAllByRestaurant(slug: string): Promise<Category[]> {
-    const restaurant = await this.em.findOne(Restaurant, { slug });
-    if (!restaurant || !restaurant.id) {
-      throw new NotFoundException(RestMessage.NOT_FOUND);
-    }
-    return this.categoryRepository.find(
-      { restaurant: restaurant, isActive: true }, { orderBy: { order: 'ASC' } });
-  }
-
-  async findAllByRestaurantId(restId: string): Promise<Category[]> {
-    return this.categoryRepository.find(
-      { restaurant: { id: restId } },
-      { orderBy: { order: 'asc' } });
-  }
-
-  async findOne(restId: string, id: string): Promise<Category> {
-    const cat = await this.categoryRepository.findOne({ id, restaurant: { id: restId } }, { populate: ['foods'] });
-    if (!cat) throw new NotFoundException(CategoryMessage.NOT_FOUND);
-
-    return {
-      id: cat.id,
-      title: cat.title,
-      isActive: cat.isActive,
-      restaurant: cat.restaurant,
-      avatarUrl: cat.avatarUrl,
-      createdAt: cat.createdAt,
-      updatedAt: cat.updatedAt,
-      foods: cat.foods.getItems().map(f => ({ id: f.id, title: f.title })),
-    } as unknown as Category;
-  }
-
-
-  async update(restId: string, id: string, dto: UpdateCategoryDto): Promise<Category> {
-    const cat = await this.categoryRepository.findOne({ id, restaurant: { id: restId } });
-    if (!cat) throw new NotFoundException(CategoryMessage.NOT_FOUND);
-    this.em.assign(cat, dto);
-    await this.em.persistAndFlush(cat);
-    return cat;
-  }
-
-  async remove(restId: string, id: string): Promise<void> {
-    const cat = await this.categoryRepository.findOne({ id, restaurant: { id: restId } });
-    if (!cat) throw new NotFoundException(CategoryMessage.NOT_FOUND);
-    cat.deletedAt = new Date();
-    await this.em.persistAndFlush(cat);
-  }
-}

src/modules/foods/providers/food.service.ts

@@ -1,214 +0,0 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
-import { CreateFoodDto } from '../dto/create-food.dto';
-import { FindFoodsDto } from '../dto/find-foods.dto';
-import { FoodRepository } from '../repositories/food.repository';
-import { CategoryRepository } from '../repositories/category.repository';
-import { EntityManager } from '@mikro-orm/postgresql';
-import { RequiredEntityData, FilterQuery } from '@mikro-orm/core';
-import { Food } from '../entities/food.entity';
-import { CategoryMessage, FoodMessage, RestMessage } from 'src/common/enums/message.enum';
-import { RestRepository } from 'src/modules/restaurants/repositories/rest.repository';
-import { CacheService } from '../../utils/cache.service';
-import { Favorite } from '../entities/favorite.entity';
-import { Inventory } from 'src/modules/inventory/entities/inventory.entity';
-
-@Injectable()
-export class FoodService {
-  constructor(
-    private readonly foodRepository: FoodRepository,
-    private readonly categoryRepository: CategoryRepository,
-    private readonly restRepository: RestRepository,
-    private readonly em: EntityManager,
-  ) { }
-
-  async create(restId: string, createFoodDto: CreateFoodDto) {
-    const { categoryId, dailyStock = 0, ...rest } = createFoodDto;
-    const restaurant = await this.restRepository.findOne({ id: restId });
-    if (!restaurant) {
-      throw new NotFoundException(RestMessage.NOT_FOUND);
-    }
-    const category = await this.categoryRepository.findOne({ id: categoryId, restaurant: { id: restId } });
-    if (!category) {
-      throw new NotFoundException(CategoryMessage.NOT_FOUND);
-    }
-
-    const { food, inventory } = await this.em.transactional(async em => {
-      // prepare data with defaults for required fields so repository.create typing is satisfied
-      const data: RequiredEntityData<Food> = {
-        desc: rest.desc,
-        isActive: rest.isActive ?? true,
-        discount: rest.discount ?? 0,
-        isSpecialOffer: rest.isSpecialOffer ?? false,
-        order: rest.order ?? null,
-        // map single-title/content DTO to localized fields
-        title: rest.title,
-        content: rest.content,
-        // numeric/array fields
-        price: rest.price ?? 0,
-        images: rest.images ?? undefined,
-        restaurant: restaurant,
-        category: category,
-      };
-
-      const food = em.create(Food, data);
-      const newInventoryRecord = em.create(Inventory, {
-        food: food,
-        availableStock: dailyStock,
-        totalStock: dailyStock,
-      });
-
-      await em.flush();
-      return { food, inventory: newInventoryRecord };
-    });
-
-    // Re-load created entities with the primary EM to ensure they're attached
-    const savedFood = food?.id
-      ? await this.foodRepository.findOne({ id: food.id }, { populate: ['category', 'restaurant'] })
-      : null;
-    const savedInventory = inventory?.id ? await this.em.findOne(Inventory, { id: inventory.id }) : inventory;
-
-    return { food: savedFood ?? food, inventory: savedInventory ?? inventory };
-  }
-
-  findAll(restId: string, dto: FindFoodsDto) {
-    return this.foodRepository.findAllPaginated(restId, dto);
-  }
-
-  /**
-   * Public food detail (only active foods are visible).
-   */
-  async findPublicById(foodId: string, userId?: string): Promise<any> {
-    const food = await this.foodRepository.findOne({ id: foodId, isActive: true }, { populate: ['category', 'inventory'] });
-    if (!food) throw new NotFoundException(FoodMessage.NOT_FOUND);
-    let isFavorite = false;
-    if (userId) {
-      isFavorite = (await this.em.count(Favorite, { user: { id: userId }, food: { id: foodId } })) > 0;
-    }
-    return {
-      ...food,
-      isFavorite,
-    };
-  }
-
-  /**
-   * Admin food detail (scoped to the authenticated restaurant).
-   */
-  async findAdminById(restId: string, id: string): Promise<Food> {
-    const food = await this.foodRepository.findOne({ id, restaurant: { id: restId } }, { populate: ['category', 'inventory'] });
-
-    if (!food) throw new NotFoundException(FoodMessage.NOT_FOUND);
-    return food;
-  }
-
-  /**
-   * Find active foods for a restaurant.
-   * @param slug - Restaurant slug identifier
-   * @returns Array of active foods
-   */
-  async findByWeekDateAndMealType(slug: string): Promise<Food[]> {
-    const restaurant = await this.restRepository.findOne({ slug });
-    if (!restaurant) {
-      throw new NotFoundException(RestMessage.NOT_FOUND);
-    }
-
-    const queryFilter: FilterQuery<Food> = {
-      restaurant: { slug },
-      isActive: true,
-    } as unknown as FilterQuery<Food>;
-
-    return this.foodRepository.find(queryFilter, {
-      populate: ['category'],
-      orderBy: { order: 'asc' }
-    });
-  }
-
-  async update(restId: string, id: string, dto: Partial<CreateFoodDto>): Promise<Food> {
-    const { categoryId, dailyStock, ...rest } = dto;
-    const food = await this.foodRepository.findOne({ id, restaurant: { id: restId } }, { populate: ['restaurant'] });
-    if (!food) {
-      throw new NotFoundException(FoodMessage.NOT_FOUND);
-    }
-
-    // attach new categories if provided (adds, does not attempt to preserve/remove existing ones)
-    if (categoryId) {
-      const category = await this.categoryRepository.findOne({ id: categoryId, restaurant: { id: restId } });
-
-      if (!category) {
-        throw new NotFoundException(CategoryMessage.NOT_FOUND);
-      }
-
-      this.em.assign(food, { category: category });
-    }
-
-    // assign other fields from DTO (excluding dailyStock handled below)
-    this.em.assign(food, rest);
-
-    // Persist food and update/create related inventory atomically
-    await this.em.transactional(async em => {
-      await em.persistAndFlush(food);
-
-      if (typeof dailyStock !== 'undefined') {
-        const inventoryRecord = await em.findOne(Inventory, { food: food });
-        if (inventoryRecord) {
-          inventoryRecord.totalStock = dailyStock;
-        } else {
-          em.create(Inventory, {
-            food: food,
-            availableStock: dailyStock,
-            totalStock: dailyStock,
-          });
-        }
-      }
-
-      await em.flush();
-    });
-
-    // Re-load the food to ensure populated relations and stable instance
-    const savedFood = await this.foodRepository.findOne({ id: food.id }, { populate: ['category', 'restaurant'] });
-
-    // Invalidate cache for the restaurant if present (optional)
-    // await this.invalidateRestaurantFoodsCache(savedFood?.restaurant?.slug);
-
-    return savedFood ?? food;
-  }
-
-  async remove(restId: string, id: string): Promise<void> {
-    const food = await this.foodRepository.findOne({ id, restaurant: { id: restId } }, { populate: ['restaurant'] });
-    if (!food) {
-      throw new NotFoundException(FoodMessage.NOT_FOUND);
-    }
-
-    // const restaurantSlug = food.restaurant.slug;
-    food.deletedAt = new Date();
-    await this.em.persistAndFlush(food);
-
-    // Invalidate cache for the restaurant
-    // await this.invalidateRestaurantFoodsCache(restaurantSlug);
-  }
-
-
-  async toggleFavorite(userId: string, foodId: string) {
-
-    const favorite = await this.em.findOne(Favorite, { user: userId, food: foodId });
-    if (favorite) {
-      return this.em.removeAndFlush(favorite);
-    }
-    const newFavorite = this.em.create(Favorite, {
-      user: userId,
-      food: foodId,
-    });
-    return this.em.persistAndFlush(newFavorite);
-  }
-
-
-  async getMyFavorites(userId: string, restId: string) {
-    return this.em.find(Favorite, { user: userId, food: { restaurant: { id: restId } } }, { populate: ['food'] });
-  }
-  /**
-   * Invalidate cache for restaurant foods
-   */
-  // private async invalidateRestaurantFoodsCache(slug: string): Promise<void> {
-  //   const cacheKey = `${this.FOODS_BY_RESTAURANT_CACHE_KEY_PREFIX}${slug}`;
-  //   await this.cacheService.del(cacheKey);
-  // }
-}

src/modules/foods/repositories/category.repository.ts

@@ -1,10 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { EntityManager, EntityRepository } from '@mikro-orm/postgresql';
-import { Category } from '../entities/category.entity';
-
-@Injectable()
-export class CategoryRepository extends EntityRepository<Category> {
-  constructor(readonly em: EntityManager) {
-    super(em, Category);
-  }
-}

src/modules/foods/repositories/food.repository.ts

@@ -1,68 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { EntityManager, EntityRepository } from '@mikro-orm/postgresql';
-import { FilterQuery } from '@mikro-orm/core';
-import { Food } from '../entities/food.entity';
-import { PaginatedResult } from 'src/common/interfaces/pagination.interface';
-
-type FindFoodsOpts = {
-  page?: number;
-  limit?: number;
-  search?: string;
-  orderBy?: string;
-  order?: 'asc' | 'desc';
-  categoryId?: string;
-  isActive?: boolean;
-};
-
-@Injectable()
-export class FoodRepository extends EntityRepository<Food> {
-  constructor(readonly em: EntityManager) {
-    super(em, Food);
-  }
-  /**
-   * Find foods with pagination and optional filters.
-   * Supports: search (title/content), categoryId, isActive, ordering.
-   */
-  async findAllPaginated(restId: string, opts: FindFoodsOpts = {}): Promise<PaginatedResult<Food>> {
-    const { page = 1, limit = 10, search, orderBy = 'order', order = 'asc', categoryId, isActive } = opts;
-
-    const offset = (page - 1) * limit;
-
-    const where: FilterQuery<Food> = { restaurant: { id: restId } };
-
-    if (typeof isActive === 'boolean') {
-      where.isActive = isActive;
-    }
-
-    if (search) {
-      const pattern = `%${search}%`;
-      where.$or = [{ title: { $ilike: pattern } }, { desc: { $ilike: pattern } }];
-    }
-
-    if (categoryId) {
-      // filter by related category (Food has a single `category` relation)
-      Object.assign(where, { category: { id: categoryId } } as unknown as FilterQuery<Food>);
-    }
-
-    const [data, total] = await this.findAndCount(where, {
-      limit,
-      offset,
-      orderBy: { [orderBy]: order.toLowerCase() as 'asc' | 'desc' },
-      populate: ['category','inventory'],
-    });
-
-    const totalPages = Math.ceil(total / limit);
-
-    return {
-      data,
-      meta: {
-        total,
-        page,
-        limit,
-        totalPages,
-      },
-    };
-
-
-  }
-}