Good afternoon people, As I did, the relationships are working as expected, however, I need to check so that the Model UserPermissionRole, only accepts registering if it already has a user, a role and a permission registered, that is, it cannot accept if it does not have: user, role and permission. Can anybody help me? Follow code below. CreateuserPermissionRoleService.ts:

import { AppError } from '../shared/errors/AppError';
import prismaClient from '../prisma';
import { UserPermissionRole } from '@prisma/client';
import { CreateUserPermissionRoleDTO } from '../dtos/create_user_permission_role_service/CreateUserPermissionRoleDTO';

// type UserPermissionRoleRequest = {
//   user_id: string;
//   role_id: string;
//   permission_id: string;
// };

class CreateUserPermissionRoleService {
  async execute({
    user_id,
    role_id,
    permission_id,
  }: CreateUserPermissionRoleDTO): Promise<UserPermissionRole> {
    const roleAlreadyExists = await prismaClient.userPermissionRole.findFirst({
      where: {
        role: {
          /**
           *
           * To implement
           *
           */
        },
      },
    });

    // console.log(roleAlreadyExists);

    if (!roleAlreadyExists) {
      throw new AppError('Role does not exists.');
    }

    const userPermissionRoleExists =
      await prismaClient.userPermissionRole.create({
        data: {
          user_id,
          role_id,
          permission_id,
        },
      });

    return userPermissionRoleExists;
  }
}

export { CreateUserPermissionRoleService };

schema.prisma;

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

model User {
  id         String   @id @default(uuid())
  name       String
  email      String   @unique
  password   String
  isAdmin    Boolean  @default(false)
  created_at DateTime @default(now())
  updated_at DateTime @updatedAt

  Client             Client[]
  userpermissionrole UserPermissionRole[]
  @@map("users")
}

model Client {
  id              String   @id @default(uuid())
  user_id         String
  name            User     @relation(fields: [user_id], references: [id])
  address         String
  city            String
  district        String
  state           String
  zipcode         String
  cnpj            String   @unique
  stateregistered String
  telephone       String
  mobile          String
  active          Boolean
  created_at      DateTime @default(now())
  updated_at      DateTime @updatedAt

  Order OrderClient[]
  @@map("clients")
}

model Product {
  id           String   @id @default(uuid())
  followUp     String
  fabric       String?
  name         String
  size         String
  color        String
  status       String
  code_karsten String
  price        Decimal  @default(0.00)
  isActive     Boolean
  created_at   DateTime @default(now())
  updated_at   DateTime @updatedAt

  Order OrderClient[]
  @@map("products")
}

model OrderClient {
  id           String   @id @default(uuid())
  name         Client   @relation(fields: [client_id], references: [id])
  client_id    String
  product      Product  @relation(fields: [product_id], references: [id])
  product_id   String
  quantity     Int
  size         String
  color        String
  status       String
  code_karsten String
  price        Decimal  @default(0.00)
  liquid       Decimal  @default(0.00)
  priceTotal   Decimal  @default(0.00)
  created_at   DateTime @default(now())
  updated_at   DateTime @updatedAt

  @@map("orders_clients")
}

model Role {
  id          String   @id @default(uuid())
  name        String
  description String
  created_at  DateTime @default(now())
  updated_at  DateTime @updatedAt

  permissions UserPermissionRole[]
  @@map("roles")
}

model Permission {
  id          String   @id @default(uuid())
  name        String
  description String
  created_at  DateTime @default(now())
  updated_at  DateTime @updatedAt

  roles UserPermissionRole[]
  @@map("permissions")
}

model UserPermissionRole {
  id            String     @id @default(uuid())
  user_id       String
  user          User       @relation(fields: [user_id], references: [id])
  role_id       String
  role          Role       @relation(fields: [role_id], references: [id])
  permission_id String
  permission    Permission @relation(fields: [permission_id], references: [id])
  created_at    DateTime   @default(now())
  updated_at    DateTime   @updatedAt

  @@map("permission_roles")
}

Something like this, I did just to try to show the idea of what I was thinking, but it didn't work.

import { AppError } from '../shared/errors/AppError';
import prismaClient from '../prisma';
import { UserPermissionRole } from '@prisma/client';
import { CreateUserPermissionRoleDTO } from '../dtos/create_user_permission_role_service/CreateUserPermissionRoleDTO';

// type UserPermissionRoleRequest = {
//   user_id: string;
//   role_id: string;
//   permission_id: string;
// };

class CreateUserPermissionRoleService {
  async execute({
    id,
    user_id,
    role_id,
    permission_id,
  }: CreateUserPermissionRoleDTO): Promise<UserPermissionRole> {
    const roleAlreadyExists = await prismaClient.userPermissionRole.findFirst({
      where: {
        role: {
          id,
        },
      },
    });

    if (roleAlreadyExists) {
      throw new AppError('Role does not exists.');
    }

    const userPermissionRoleExists =
      await prismaClient.userPermissionRole.create({
        data: {
          user_id,
          role_id,
          permission_id,
        },
      });

    return userPermissionRoleExists;
  }
}

export { CreateUserPermissionRoleService };

I CAN SOLVE IT THIS WAY:

import { AppError } from '../shared/errors/AppError';
import prismaClient from '../prisma';
import { UserPermissionRole } from '@prisma/client';
import { CreateUserPermissionRoleDTO } from '../dtos/create_user_permission_role_service/CreateUserPermissionRoleDTO';

class CreateUserPermissionRoleService {
  async execute({
    user_id,
    role_id,
    permission_id,
  }: CreateUserPermissionRoleDTO): Promise<UserPermissionRole> {
    try {
      const userPermissionRoleExists =
        await prismaClient.userPermissionRole.create({
          data: {
            user_id,
            role_id,
            permission_id,
          },
        });

      return userPermissionRoleExists;
    } catch {
      throw new AppError('User or role or permission doesnt exists!');
    }
  }
}

export { CreateUserPermissionRoleService };