git init

server/src/app.module.ts

@@ -0,0 +1,19 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { PrismaModule } from './prisma/prisma.module';
+import { HealthModule } from './health/health.module';
+import { EquipmentTypeModule } from './modules/equipment-type/equipment-type.module';
+import { EquipmentModule } from './modules/equipment/equipment.module';
+import { RepairOrderModule } from './modules/repair-order/repair-order.module';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({ isGlobal: true }),
+    PrismaModule,
+    HealthModule,
+    EquipmentTypeModule,
+    EquipmentModule,
+    RepairOrderModule,
+  ],
+})
+export class AppModule {}

server/src/health/health.controller.ts

@@ -0,0 +1,9 @@
+import { Controller, Get } from '@nestjs/common';
+
+@Controller('health')
+export class HealthController {
+  @Get()
+  getHealth() {
+    return { status: 'ok' };
+  }
+}

server/src/health/health.module.ts

@@ -0,0 +1,7 @@
+import { Module } from '@nestjs/common';
+import { HealthController } from './health.controller';
+
+@Module({
+  controllers: [HealthController],
+})
+export class HealthModule {}

server/src/main.ts

@@ -0,0 +1,12 @@
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  app.enableCors({
+    origin: true,
+    exposedHeaders: ['Content-Range'],
+  });
+  await app.listen(process.env.PORT ?? 3000);
+}
+bootstrap();

server/src/modules/equipment-type/dto/create-equipment-type.dto.ts

@@ -0,0 +1,7 @@
+export class CreateEquipmentTypeDto {
+  code: string;
+  name: string;
+  manufacturer?: string;
+  maintenanceIntervalHours?: number;
+  overhaulIntervalHours?: number;
+}

server/src/modules/equipment-type/dto/update-equipment-type.dto.ts

@@ -0,0 +1,6 @@
+export class UpdateEquipmentTypeDto {
+  name?: string;
+  manufacturer?: string;
+  maintenanceIntervalHours?: number;
+  overhaulIntervalHours?: number;
+}

server/src/modules/equipment-type/equipment-type.controller.ts

@@ -0,0 +1,38 @@
+import { Controller, Get, Post, Patch, Delete, Param, Body, Query, Res } from '@nestjs/common';
+import { Response } from 'express';
+import { EquipmentTypeService } from './equipment-type.service';
+import { CreateEquipmentTypeDto } from './dto/create-equipment-type.dto';
+import { UpdateEquipmentTypeDto } from './dto/update-equipment-type.dto';
+
+@Controller('equipment-types')
+export class EquipmentTypeController {
+  constructor(private readonly equipmentTypeService: EquipmentTypeService) {}
+
+  @Get()
+  async findAll(@Query() query: any, @Res() res: Response) {
+    const result = await this.equipmentTypeService.findAll(query);
+    res.set('Content-Range', `equipment-types ${query._start || 0}-${query._end || result.total}/${result.total}`);
+    res.set('Access-Control-Expose-Headers', 'Content-Range');
+    return res.json(result.data);
+  }
+
+  @Get(':code')
+  findOne(@Param('code') code: string) {
+    return this.equipmentTypeService.findOne(code);
+  }
+
+  @Post()
+  create(@Body() dto: CreateEquipmentTypeDto) {
+    return this.equipmentTypeService.create(dto);
+  }
+
+  @Patch(':code')
+  update(@Param('code') code: string, @Body() dto: UpdateEquipmentTypeDto) {
+    return this.equipmentTypeService.update(code, dto);
+  }
+
+  @Delete(':code')
+  remove(@Param('code') code: string) {
+    return this.equipmentTypeService.remove(code);
+  }
+}

server/src/modules/equipment-type/equipment-type.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { EquipmentTypeController } from './equipment-type.controller';
+import { EquipmentTypeService } from './equipment-type.service';
+
+@Module({
+  controllers: [EquipmentTypeController],
+  providers: [EquipmentTypeService],
+})
+export class EquipmentTypeModule {}

server/src/modules/equipment-type/equipment-type.service.ts

@@ -0,0 +1,78 @@
+import { Injectable } from '@nestjs/common';
+import { PrismaService } from '../../prisma/prisma.service';
+import { CreateEquipmentTypeDto } from './dto/create-equipment-type.dto';
+import { UpdateEquipmentTypeDto } from './dto/update-equipment-type.dto';
+
+@Injectable()
+export class EquipmentTypeService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async findAll(query: {
+    _start?: string;
+    _end?: string;
+    _sort?: string;
+    _order?: string;
+    [key: string]: any;
+  }) {
+    const start = parseInt(query._start) || 0;
+    const end = parseInt(query._end) || 10;
+    const take = end - start;
+    const skip = start;
+    const sortField = 'code';
+    const sortOrder = (query._order || 'ASC').toLowerCase() as 'asc' | 'desc';
+
+    const where: any = {};
+    if (query.code) where.code = { contains: query.code, mode: 'insensitive' };
+    if (query.name) where.name = { contains: query.name, mode: 'insensitive' };
+    if (query.manufacturer)
+      where.manufacturer = {
+        contains: query.manufacturer,
+        mode: 'insensitive',
+      };
+    if (query.id) {
+      const ids = Array.isArray(query.id) ? query.id : [query.id];
+      where.code = { in: ids };
+    }
+
+    const [data, total] = await Promise.all([
+      this.prisma.equipmentType.findMany({
+        where,
+        skip,
+        take,
+        orderBy: { [sortField]: sortOrder },
+      }),
+      this.prisma.equipmentType.count({ where }),
+    ]);
+
+    return {
+      data: data.map((item) => ({ id: item.code, ...item })),
+      total,
+    };
+  }
+
+  async findOne(code: string) {
+    const record = await this.prisma.equipmentType.findUniqueOrThrow({
+      where: { code },
+    });
+    return { id: record.code, ...record };
+  }
+
+  async create(dto: CreateEquipmentTypeDto) {
+    const record = await this.prisma.equipmentType.create({ data: dto });
+    return { id: record.code, ...record };
+  }
+
+  async update(code: string, dto: UpdateEquipmentTypeDto) {
+    const { id, code: _pk, ...data } = dto as any;
+    const record = await this.prisma.equipmentType.update({
+      where: { code },
+      data,
+    });
+    return { id: record.code, ...record };
+  }
+
+  async remove(code: string) {
+    const record = await this.prisma.equipmentType.delete({ where: { code } });
+    return { id: record.code, ...record };
+  }
+}

server/src/modules/equipment/dto/create-equipment.dto.ts

@@ -0,0 +1,13 @@
+export class CreateEquipmentDto {
+  inventoryNumber: string;
+  serialNumber?: string;
+  name: string;
+  equipmentTypeCode: string;
+  status?: string;
+  location?: string;
+  commissionedAt?: string;
+  totalEngineHours?: string;
+  engineHoursSinceLastRepair?: string;
+  lastRepairAt?: string;
+  notes?: string;
+}

server/src/modules/equipment/dto/update-equipment.dto.ts

@@ -0,0 +1,13 @@
+export class UpdateEquipmentDto {
+  inventoryNumber?: string;
+  serialNumber?: string;
+  name?: string;
+  equipmentTypeCode?: string;
+  status?: string;
+  location?: string;
+  commissionedAt?: string;
+  totalEngineHours?: string;
+  engineHoursSinceLastRepair?: string;
+  lastRepairAt?: string;
+  notes?: string;
+}

server/src/modules/equipment/equipment.controller.ts

@@ -0,0 +1,38 @@
+import { Controller, Get, Post, Patch, Delete, Param, Body, Query, Res } from '@nestjs/common';
+import { Response } from 'express';
+import { EquipmentService } from './equipment.service';
+import { CreateEquipmentDto } from './dto/create-equipment.dto';
+import { UpdateEquipmentDto } from './dto/update-equipment.dto';
+
+@Controller('equipment')
+export class EquipmentController {
+  constructor(private readonly equipmentService: EquipmentService) {}
+
+  @Get()
+  async findAll(@Query() query: any, @Res() res: Response) {
+    const result = await this.equipmentService.findAll(query);
+    res.set('Content-Range', `equipment ${query._start || 0}-${query._end || result.total}/${result.total}`);
+    res.set('Access-Control-Expose-Headers', 'Content-Range');
+    return res.json(result.data);
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.equipmentService.findOne(id);
+  }
+
+  @Post()
+  create(@Body() dto: CreateEquipmentDto) {
+    return this.equipmentService.create(dto);
+  }
+
+  @Patch(':id')
+  update(@Param('id') id: string, @Body() dto: UpdateEquipmentDto) {
+    return this.equipmentService.update(id, dto);
+  }
+
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.equipmentService.remove(id);
+  }
+}

server/src/modules/equipment/equipment.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { EquipmentController } from './equipment.controller';
+import { EquipmentService } from './equipment.service';
+
+@Module({
+  controllers: [EquipmentController],
+  providers: [EquipmentService],
+})
+export class EquipmentModule {}

server/src/modules/equipment/equipment.service.ts

@@ -0,0 +1,88 @@
+import { Injectable } from '@nestjs/common';
+import { Prisma } from '@prisma/client';
+import { PrismaService } from '../../prisma/prisma.service';
+import { CreateEquipmentDto } from './dto/create-equipment.dto';
+import { UpdateEquipmentDto } from './dto/update-equipment.dto';
+
+function serializeRecord(record: any) {
+  return {
+    ...record,
+    totalEngineHours: record.totalEngineHours?.toString() ?? null,
+    engineHoursSinceLastRepair: record.engineHoursSinceLastRepair?.toString() ?? null,
+    commissionedAt: record.commissionedAt?.toISOString() ?? null,
+    lastRepairAt: record.lastRepairAt?.toISOString() ?? null,
+  };
+}
+
+@Injectable()
+export class EquipmentService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async findAll(query: { _start?: string; _end?: string; _sort?: string; _order?: string; [key: string]: any }) {
+    const start = parseInt(query._start) || 0;
+    const end = parseInt(query._end) || 10;
+    const take = end - start;
+    const skip = start;
+    const sortField = query._sort || 'id';
+    const sortOrder = (query._order || 'ASC').toLowerCase() as 'asc' | 'desc';
+
+    const where: any = {};
+    if (query.inventoryNumber) where.inventoryNumber = { contains: query.inventoryNumber, mode: 'insensitive' };
+    if (query.name) where.name = { contains: query.name, mode: 'insensitive' };
+    if (query.equipmentTypeCode) where.equipmentTypeCode = query.equipmentTypeCode;
+    if (query.status) where.status = query.status;
+    if (query.location) where.location = { contains: query.location, mode: 'insensitive' };
+    if (query.id) {
+      const ids = Array.isArray(query.id) ? query.id : [query.id];
+      where.id = { in: ids };
+    }
+
+    const [data, total] = await Promise.all([
+      this.prisma.equipment.findMany({
+        where,
+        skip,
+        take,
+        orderBy: { [sortField]: sortOrder },
+      }),
+      this.prisma.equipment.count({ where }),
+    ]);
+
+    return {
+      data: data.map(serializeRecord),
+      total,
+    };
+  }
+
+  async findOne(id: string) {
+    const record = await this.prisma.equipment.findUniqueOrThrow({ where: { id } });
+    return serializeRecord(record);
+  }
+
+  async create(dto: CreateEquipmentDto) {
+    const data: any = { ...dto };
+    if (dto.commissionedAt) data.commissionedAt = new Date(dto.commissionedAt);
+    if (dto.lastRepairAt) data.lastRepairAt = new Date(dto.lastRepairAt);
+    if (dto.totalEngineHours) data.totalEngineHours = new Prisma.Decimal(dto.totalEngineHours);
+    if (dto.engineHoursSinceLastRepair) data.engineHoursSinceLastRepair = new Prisma.Decimal(dto.engineHoursSinceLastRepair);
+
+    const record = await this.prisma.equipment.create({ data });
+    return serializeRecord(record);
+  }
+
+  async update(id: string, dto: UpdateEquipmentDto) {
+    const { id: _pk, ...rest } = dto as any;
+    const data: any = { ...rest };
+    if (data.commissionedAt) data.commissionedAt = new Date(data.commissionedAt);
+    if (data.lastRepairAt) data.lastRepairAt = new Date(data.lastRepairAt);
+    if (data.totalEngineHours !== undefined && data.totalEngineHours !== null) data.totalEngineHours = new Prisma.Decimal(data.totalEngineHours);
+    if (data.engineHoursSinceLastRepair !== undefined && data.engineHoursSinceLastRepair !== null) data.engineHoursSinceLastRepair = new Prisma.Decimal(data.engineHoursSinceLastRepair);
+
+    const record = await this.prisma.equipment.update({ where: { id }, data });
+    return serializeRecord(record);
+  }
+
+  async remove(id: string) {
+    const record = await this.prisma.equipment.delete({ where: { id } });
+    return serializeRecord(record);
+  }
+}

server/src/modules/repair-order/dto/create-repair-order.dto.ts

@@ -0,0 +1,13 @@
+export class CreateRepairOrderDto {
+  number: string;
+  equipmentId: string;
+  repairKind: string;
+  status?: string;
+  plannedAt: string;
+  startedAt?: string;
+  completedAt?: string;
+  contractor?: string;
+  engineHoursAtRepair?: string;
+  description?: string;
+  notes?: string;
+}

server/src/modules/repair-order/dto/update-repair-order.dto.ts

@@ -0,0 +1,13 @@
+export class UpdateRepairOrderDto {
+  number?: string;
+  equipmentId?: string;
+  repairKind?: string;
+  status?: string;
+  plannedAt?: string;
+  startedAt?: string;
+  completedAt?: string;
+  contractor?: string;
+  engineHoursAtRepair?: string;
+  description?: string;
+  notes?: string;
+}

server/src/modules/repair-order/repair-order.controller.ts

@@ -0,0 +1,38 @@
+import { Controller, Get, Post, Patch, Delete, Param, Body, Query, Res } from '@nestjs/common';
+import { Response } from 'express';
+import { RepairOrderService } from './repair-order.service';
+import { CreateRepairOrderDto } from './dto/create-repair-order.dto';
+import { UpdateRepairOrderDto } from './dto/update-repair-order.dto';
+
+@Controller('repair-orders')
+export class RepairOrderController {
+  constructor(private readonly repairOrderService: RepairOrderService) {}
+
+  @Get()
+  async findAll(@Query() query: any, @Res() res: Response) {
+    const result = await this.repairOrderService.findAll(query);
+    res.set('Content-Range', `repair-orders ${query._start || 0}-${query._end || result.total}/${result.total}`);
+    res.set('Access-Control-Expose-Headers', 'Content-Range');
+    return res.json(result.data);
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.repairOrderService.findOne(id);
+  }
+
+  @Post()
+  create(@Body() dto: CreateRepairOrderDto) {
+    return this.repairOrderService.create(dto);
+  }
+
+  @Patch(':id')
+  update(@Param('id') id: string, @Body() dto: UpdateRepairOrderDto) {
+    return this.repairOrderService.update(id, dto);
+  }
+
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.repairOrderService.remove(id);
+  }
+}

server/src/modules/repair-order/repair-order.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { RepairOrderController } from './repair-order.controller';
+import { RepairOrderService } from './repair-order.service';
+
+@Module({
+  controllers: [RepairOrderController],
+  providers: [RepairOrderService],
+})
+export class RepairOrderModule {}

server/src/modules/repair-order/repair-order.service.ts

@@ -0,0 +1,88 @@
+import { Injectable } from '@nestjs/common';
+import { Prisma } from '@prisma/client';
+import { PrismaService } from '../../prisma/prisma.service';
+import { CreateRepairOrderDto } from './dto/create-repair-order.dto';
+import { UpdateRepairOrderDto } from './dto/update-repair-order.dto';
+
+function serializeRecord(record: any) {
+  return {
+    ...record,
+    engineHoursAtRepair: record.engineHoursAtRepair?.toString() ?? null,
+    plannedAt: record.plannedAt?.toISOString() ?? null,
+    startedAt: record.startedAt?.toISOString() ?? null,
+    completedAt: record.completedAt?.toISOString() ?? null,
+  };
+}
+
+@Injectable()
+export class RepairOrderService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async findAll(query: { _start?: string; _end?: string; _sort?: string; _order?: string; [key: string]: any }) {
+    const start = parseInt(query._start) || 0;
+    const end = parseInt(query._end) || 10;
+    const take = end - start;
+    const skip = start;
+    const sortField = query._sort || 'id';
+    const sortOrder = (query._order || 'ASC').toLowerCase() as 'asc' | 'desc';
+
+    const where: any = {};
+    if (query.number) where.number = { contains: query.number, mode: 'insensitive' };
+    if (query.equipmentId) where.equipmentId = query.equipmentId;
+    if (query.repairKind) where.repairKind = query.repairKind;
+    if (query.status) where.status = query.status;
+    if (query.contractor) where.contractor = { contains: query.contractor, mode: 'insensitive' };
+    if (query.id) {
+      const ids = Array.isArray(query.id) ? query.id : [query.id];
+      where.id = { in: ids };
+    }
+
+    const [data, total] = await Promise.all([
+      this.prisma.repairOrder.findMany({
+        where,
+        skip,
+        take,
+        orderBy: { [sortField]: sortOrder },
+      }),
+      this.prisma.repairOrder.count({ where }),
+    ]);
+
+    return {
+      data: data.map(serializeRecord),
+      total,
+    };
+  }
+
+  async findOne(id: string) {
+    const record = await this.prisma.repairOrder.findUniqueOrThrow({ where: { id } });
+    return serializeRecord(record);
+  }
+
+  async create(dto: CreateRepairOrderDto) {
+    const data: any = { ...dto };
+    if (dto.plannedAt) data.plannedAt = new Date(dto.plannedAt);
+    if (dto.startedAt) data.startedAt = new Date(dto.startedAt);
+    if (dto.completedAt) data.completedAt = new Date(dto.completedAt);
+    if (dto.engineHoursAtRepair) data.engineHoursAtRepair = new Prisma.Decimal(dto.engineHoursAtRepair);
+
+    const record = await this.prisma.repairOrder.create({ data });
+    return serializeRecord(record);
+  }
+
+  async update(id: string, dto: UpdateRepairOrderDto) {
+    const { id: _pk, ...rest } = dto as any;
+    const data: any = { ...rest };
+    if (data.plannedAt) data.plannedAt = new Date(data.plannedAt);
+    if (data.startedAt) data.startedAt = new Date(data.startedAt);
+    if (data.completedAt) data.completedAt = new Date(data.completedAt);
+    if (data.engineHoursAtRepair !== undefined && data.engineHoursAtRepair !== null) data.engineHoursAtRepair = new Prisma.Decimal(data.engineHoursAtRepair);
+
+    const record = await this.prisma.repairOrder.update({ where: { id }, data });
+    return serializeRecord(record);
+  }
+
+  async remove(id: string) {
+    const record = await this.prisma.repairOrder.delete({ where: { id } });
+    return serializeRecord(record);
+  }
+}

server/src/prisma/prisma.module.ts

@@ -0,0 +1,9 @@
+import { Global, Module } from '@nestjs/common';
+import { PrismaService } from './prisma.service';
+
+@Global()
+@Module({
+  providers: [PrismaService],
+  exports: [PrismaService],
+})
+export class PrismaModule {}

server/src/prisma/prisma.service.ts

@@ -0,0 +1,9 @@
+import { Injectable, OnModuleInit } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+
+@Injectable()
+export class PrismaService extends PrismaClient implements OnModuleInit {
+  async onModuleInit() {
+    await this.$connect();
+  }
+}