Implemented Supplier Module

Author: ahmadogo

backend/package-lock.json

@@ -23,15 +23,16 @@
     "@nestjs/common": "^10.0.0",
     "@nestjs/config": "^3.0.0",
     "@nestjs/core": "^10.0.0",
+    "@nestjs/mapped-types": "*",
     "@nestjs/platform-express": "^10.0.0",
-    "@nestjs/typeorm": "^10.0.0",
+    "@nestjs/typeorm": "^10.0.2",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.0",
     "nestjs-i18n": "^10.5.1",
     "pg": "^8.11.3",
     "reflect-metadata": "^0.2.0",
     "rxjs": "^7.8.1",
-    "typeorm": "^0.3.17"
+    "typeorm": "^0.3.27"
   },
   "devDependencies": {
     "@nestjs/cli": "^10.0.0",

backend/package.json

@@ -1,50 +1,62 @@
 import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
 import { AssetCategoriesModule } from './asset-categories/asset-categories.module';
 import { AssetCategory } from './asset-categories/asset-category.entity';
 import { DepartmentsModule } from './departments/departments.module';
 import { Department } from './departments/department.entity';
+import { SuppliersModule } from './suppliers/suppliers.module';
+import {
+  I18nModule,
+  QueryResolver,
+  HeaderResolver,
+  AcceptLanguageResolver,
+} from 'nestjs-i18n';
+import * as path from 'path';
+import { Supplier } from './suppliers/entities/supplier.entity';
+import { TypeOrmModule } from '@nestjs/typeorm';
 
 @Module({
   imports: [
     ConfigModule.forRoot({
       isGlobal: true,
     }),
-    TypeOrmModule.forRootAsync({
-      imports: [ConfigModule,
-         // --- ADD THIS CONFIGURATION ---
-      I18nModule.forRoot({
+
+    // i18n should be registered at top-level imports (not nested inside TypeOrm import)
+    I18nModule.forRoot({
       fallbackLanguage: 'en',
       loaderOptions: {
-        path: path.join(__dirname, '/i18n/'), // Directory for translation files
-        watch: true, // Watch for changes in translation files
+        path: path.join(__dirname, '/i18n/'),
+        watch: true,
       },
       resolvers: [
-        // Order matters: checks query param, then header, then browser settings
-        new QueryResolver(['lang', 'l']),
-        new HeaderResolver(['x-custom-lang-header']),
-        AcceptLanguageResolver, // Standard 'Accept-Language' header
+        { use: QueryResolver, options: ['lang', 'l'] },
+        { use: HeaderResolver, options: ['x-custom-lang-header'] },
+        AcceptLanguageResolver,
       ],
     }),
-    // --- END OF CONFIGURATION ---
-  ],],
+
+    // TypeORM async config
+    TypeOrmModule.forRootAsync({
+      imports: [ConfigModule],
       useFactory: (configService: ConfigService) => ({
         type: 'postgres',
-        host: configService.get('DB_HOST', 'localhost'),
-        port: configService.get('DB_PORT', 5432),
-        username: configService.get('DB_USERNAME', 'postgres'),
-        password: configService.get('DB_PASSWORD', 'password'),
-        database: configService.get('DB_DATABASE', 'manage_assets'),
-        entities: [AssetCategory, Department],
-        synchronize: configService.get('NODE_ENV') !== 'production', // Only for development
+        host: configService.get<string>('DB_HOST', 'localhost'),
+        port: Number(configService.get<number>('DB_PORT', 5432)),
+        username: configService.get<string>('DB_USERNAME', 'postgres'),
+        password: configService.get<string>('DB_PASSWORD', 'password'),
+        database: configService.get<string>('DB_DATABASE', 'manage_assets'),
+        // include all entity classes used by your app
+        entities: [AssetCategory, Department, Supplier],
+        synchronize: configService.get<string>('NODE_ENV') !== 'production',
       }),
       inject: [ConfigService],
     }),
+
     AssetCategoriesModule,
     DepartmentsModule,
+    SuppliersModule,
   ],
   controllers: [AppController],
   providers: [AppService],

backend/src/app.module.ts

@@ -0,0 +1,21 @@
+import { IsEmail, IsNotEmpty, IsOptional, IsString } from 'class-validator';
+
+export class CreateSupplierDto {
+  @IsString()
+  @IsNotEmpty()
+  name: string;
+
+  @IsOptional()
+  @IsString()
+  contactInfo?: string;
+
+  @IsOptional()
+  @IsString()
+  address?: string;
+
+  @IsEmail()
+  email: string;
+
+  @IsString()
+  phone: string;
+}

backend/src/suppliers/dto/create-supplier.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateSupplierDto } from './create-supplier.dto';
+
+export class UpdateSupplierDto extends PartialType(CreateSupplierDto) {}

backend/src/suppliers/dto/update-supplier.dto.ts

@@ -0,0 +1,26 @@
+import { Entity, PrimaryGeneratedColumn, Column, OneToMany } from 'typeorm';
+
+@Entity('suppliers')
+export class Supplier {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column()
+  name: string;
+
+  @Column({ nullable: true })
+  contactInfo: string;
+
+  @Column({ nullable: true })
+  address: string;
+
+  @Column({ unique: true })
+  email: string;
+
+  @Column()
+  phone: string;
+
+  // This should be uncommented when the Asset entity is created
+  //   @OneToMany(() => Asset, (asset) => asset.supplier)
+  //   assets: Asset[];
+}

backend/src/suppliers/entities/supplier.entity.ts

@@ -0,0 +1,42 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  Param,
+  Put,
+  Delete,
+} from '@nestjs/common';
+import { SuppliersService } from './suppliers.service';
+import { CreateSupplierDto } from './dto/create-supplier.dto';
+import { UpdateSupplierDto } from './dto/update-supplier.dto';
+
+@Controller('suppliers')
+export class SuppliersController {
+  constructor(private readonly suppliersService: SuppliersService) {}
+
+  @Post()
+  create(@Body() dto: CreateSupplierDto) {
+    return this.suppliersService.create(dto);
+  }
+
+  @Get()
+  findAll() {
+    return this.suppliersService.findAll();
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.suppliersService.findOne(id);
+  }
+
+  @Put(':id')
+  update(@Param('id') id: string, @Body() dto: UpdateSupplierDto) {
+    return this.suppliersService.update(id, dto);
+  }
+
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.suppliersService.remove(id);
+  }
+}

backend/src/suppliers/suppliers.controller.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { SuppliersService } from './suppliers.service';
+import { SuppliersController } from './suppliers.controller';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Supplier } from './entities/supplier.entity';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Supplier])],
+  controllers: [SuppliersController],
+  providers: [SuppliersService],
+})
+export class SuppliersModule {}

backend/src/suppliers/suppliers.module.ts

@@ -0,0 +1,42 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { CreateSupplierDto } from './dto/create-supplier.dto';
+import { UpdateSupplierDto } from './dto/update-supplier.dto';
+import { Supplier } from './entities/supplier.entity';
+
+@Injectable()
+export class SuppliersService {
+  constructor(
+    @InjectRepository(Supplier)
+    private suppliersRepo: Repository<Supplier>,
+  ) {}
+
+  create(dto: CreateSupplierDto): Promise<Supplier> {
+    const supplier = this.suppliersRepo.create(dto);
+    return this.suppliersRepo.save(supplier);
+  }
+
+  findAll(): Promise<Supplier[]> {
+    return this.suppliersRepo.find({ relations: ['assets'] });
+  }
+
+  public async findOne(id: string): Promise<Supplier> {
+    const supplier = await this.suppliersRepo.findOne({
+      where: { id },
+      relations: ['assets'],
+    });
+    if (!supplier) throw new NotFoundException(`Supplier ${id} not found`);
+    return supplier;
+  }
+
+  public async update(id: string, dto: UpdateSupplierDto): Promise<Supplier> {
+    const supplier = await this.findOne(id);
+    Object.assign(supplier, dto);
+    return this.suppliersRepo.save(supplier);
+  }
+
+  public async remove(id: string): Promise<void> {
+    await this.suppliersRepo.delete(id);
+  }
+}