inkreach-official-website/apps/api/src/countries/countries.service.ts

import { Prisma } from '@prisma/client';
import {
  BadRequestException,
  ConflictException,
  Injectable,
  NotFoundException,
} from '@nestjs/common';
import { PrismaService } from '../prisma/prisma.service';
import { PublicCacheService } from '../public/public-cache.service';
import { CreateCountryDto } from './dto/create-country.dto';
import { UpdateCountryDto } from './dto/update-country.dto';
import { ReorderCountriesDto } from './dto/reorder-countries.dto';

@Injectable()
export class CountriesService {
  constructor(
    private readonly prisma: PrismaService,
    private readonly publicCache: PublicCacheService,
  ) {}

  findAll() {
    return this.prisma.country.findMany({
      orderBy: [{ sortOrder: 'asc' }, { id: 'asc' }],
    });
  }

  /** 批量保存拖拽后的顺序（全量提交，sortOrder = 目标下标） */
  async reorder(dto: ReorderCountriesDto) {
    await this.prisma.$transaction(
      dto.items.map((item) =>
        this.prisma.country.update({
          where: { id: BigInt(item.id) },
          data: { sortOrder: item.sortOrder },
        }),
      ),
    );
    this.publicCache.bump('meta');
    return this.findAll();
  }

  async findOne(id: bigint) {
    const country = await this.prisma.country.findUnique({ where: { id } });
    if (!country) {
      throw new NotFoundException(`Country ${id} not found`);
    }
    return country;
  }

  async create(dto: CreateCountryDto) {
    try {
      const created = await this.prisma.country.create({
        data: {
          countryName: dto.countryName,
          countryIcon: dto.countryIcon ?? null,
        },
      });
      this.publicCache.bump('meta');
      return created;
    } catch (err) {
      if (
        err instanceof Prisma.PrismaClientKnownRequestError &&
        err.code === 'P2002'
      ) {
        throw new ConflictException('Country name already exists');
      }
      throw err;
    }
  }

  async update(id: bigint, dto: UpdateCountryDto) {
    await this.findOne(id);
    try {
      const updated = await this.prisma.country.update({
        where: { id },
        data: {
          countryName: dto.countryName,
          countryIcon: dto.countryIcon === undefined ? undefined : dto.countryIcon,
        },
      });
      this.publicCache.bump('meta');
      return updated;
    } catch (err) {
      if (
        err instanceof Prisma.PrismaClientKnownRequestError &&
        err.code === 'P2002'
      ) {
        throw new ConflictException('Country name already exists');
      }
      throw err;
    }
  }

  async remove(id: bigint) {
    await this.findOne(id);
    try {
      const removed = await this.prisma.country.delete({ where: { id } });
      this.publicCache.bump('meta');
      return removed;
    } catch (err) {
      if (this.isForeignKeyViolation(err)) {
        throw new BadRequestException(
          'Country is referenced by goods or positions and cannot be deleted',
        );
      }
      throw err;
    }
  }

  private isForeignKeyViolation(err: unknown): boolean {
    if (err instanceof Prisma.PrismaClientKnownRequestError) {
      // P2003 = FK constraint violation
      return err.code === 'P2003';
    }
    // Fallback: Prisma sometimes surfaces FK violations as UnknownRequestError
    // when the constraint check happens server-side before the typed error
    // is mapped (e.g. cascading RESTRICT).
    if (err instanceof Prisma.PrismaClientUnknownRequestError) {
      const msg = err.message ?? '';
      return (
        msg.includes('foreign key constraint') ||
        msg.includes('RESTRICT') ||
        msg.includes('violates')
      );
    }
    return false;
  }
}