feat: append uniq validator for name field of content-type

apps/server/src/app/contact-type/dto/contact-type.dto.ts

@@ -1,9 +1,17 @@
 import { ApiProperty } from "@nestjs/swagger";
 import { contact_types } from "@prisma/client";
 import { IsNotEmpty } from "class-validator";
+import { IsAlreadyExist } from "../../shared/validators/is-already-exist";
 export class ContactTypeDto implements Omit<contact_types, "id"> {
   @ApiProperty()
   @IsNotEmpty()
+  @IsAlreadyExist(
+    { entity: "contact_types", field: "name" },
+    {
+      message: ({ value, property }) =>
+        `field ${property} with ${value} is found`,
+    }
+  )
   name!: string;
 
   @ApiProperty()

apps/server/src/app/database/db.interface.ts

@@ -0,0 +1,7 @@
+export interface DbInterface {
+  isAlreadyExist(
+    value: unknown,
+    entity: string,
+    field: string
+  ): Promise<boolean>;
+}

apps/server/src/app/database/db.service.ts

@@ -0,0 +1,26 @@
+import { DbInterface } from "./db.interface";
+import { Service } from "typedi";
+import { PrismaClientService } from "@site15/prisma/server";
+
+@Service()
+export class DbService implements DbInterface {
+  static instance: DbInterface;
+  private readonly prismaClintService: PrismaClientService;
+  constructor() {
+    DbService.instance = this;
+    this.prismaClintService = PrismaClientService.instance;
+  }
+
+  async isAlreadyExist(
+    value: unknown,
+    entity: string,
+    field: string
+  ): Promise<boolean> {
+    const data = await this.prismaClintService[entity].findFirst({
+      where: {
+        [field]: value,
+      },
+    });
+    return !!data;
+  }
+}

apps/server/src/app/shared/validators/is-already-exist.ts

@@ -0,0 +1,52 @@
+import {
+  registerDecorator,
+  ValidationArguments,
+  ValidationOptions,
+  ValidatorConstraint,
+  ValidatorConstraintInterface,
+} from "class-validator";
+import { PrismaClientService } from "@site15/prisma/server";
+import { Container } from "typedi";
+import { DbInterface } from "../../database/db.interface";
+import { DbService } from "../../database/db.service";
+
+interface Data {
+  entity: string;
+  field: string;
+}
+
+@ValidatorConstraint({ async: true })
+class ExistsConstraint implements ValidatorConstraintInterface {
+  private dbService: DbInterface;
+  constructor() {
+    this.dbService = Container.get<DbInterface>(DbService);
+  }
+  async validate(
+    currentValue: unknown,
+    args?: ValidationArguments
+  ): Promise<boolean> {
+    const entity = args?.constraints[0]?.entity;
+    const field = args?.constraints[0]?.field;
+    return !(await this.dbService.isAlreadyExist(currentValue, entity, field));
+  }
+
+  defaultMessage(validationArguments?: ValidationArguments): string {
+    const data = validationArguments?.constraints[0];
+    return `${data.entity} field ${validationArguments?.value} is found.`;
+  }
+}
+
+export function IsAlreadyExist(
+  data: Data,
+  validationOptions?: ValidationOptions
+) {
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  return (object: Object, propertyName: string) =>
+    registerDecorator({
+      target: object.constructor,
+      propertyName,
+      options: validationOptions,
+      constraints: [data],
+      validator: ExistsConstraint,
+    });
+}