graphql prisma query get artists who has song track

Question

I have three table, artist, album and track. I want to query artist who have at least one song track.

Here is my graphql prisma schema. May I know how write the query?

generator client {
  provider = "prisma-client-js"
  binaryTargets = ["native", "linux-musl"]
}

generator typegraphql {
   provider           = "typegraphql-prisma"
  emitTranspiledCode = true
}

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

model Artist {
  id              String    @id @default(cuid())
  name            String    @unique @db.VarChar(255)
  bio             String?   @db.VarChar(1024)
  profile_picture String    @db.VarChar(512)
  albums          Album[]
  tracks          Track[]
  active          Boolean   @default(true)
  user            User      @relation(fields: [user_id], references: [id])
  user_id         String
  created_at      DateTime  @default(now())
  updated_at      DateTime? @updatedAt

  @@map("artists")
}

model Album {
  id          String    @id @default(cuid())
  title       String    @db.VarChar(255)
  album_cover String    @db.VarChar(512)
  description String?   @db.VarChar(5120)
  released    Int       @default(1900)
  artists     Artist[]
  genres      Genre[]
  tracks      Track[]
  active      Boolean   @default(true)
  user        User      @relation(fields: [user_id], references: [id])
  user_id     String
  created_at  DateTime  @default(now())
  updated_at  DateTime? @updatedAt

  @@map("albums")
}

model Track {
  id          String       @id @default(cuid())
  title       String       @db.VarChar(255)
  description String?      @db.VarChar(5120)
  lyric     String?      @db.LongText
  mp3_url     String       @db.VarChar(1024)
  youtube_url String       @db.VarChar(1024)
  band       String?      @db.VarChar(255)
  duration    Int          @default(0)
  artists     Artist[]
  album       Album        @relation(fields: [album_id], references: [id])
  album_id    String
  songWriters SongWriter[]
  active      Boolean      @default(true)
  user        User         @relation(fields: [user_id], references: [id])
  user_id     String
  created_at  DateTime     @default(now())
  updated_at  DateTime?    @updatedAt

  @@map("tracks")
}

Here is Resolver

import { Resolver, ArgsType, Field, Args, Query, Ctx, ObjectType, 
Int } from "type-graphql";
import { Artist } from "@generated/type-graphql";
import { Context } from "../interfaces";

@ArgsType()
export class ArtistArgs {
  @Field((type) => Int, { nullable: false })
  page!: number;

  @Field((type) => Int, { nullable: false })
  take!: number;
}

@ObjectType()
export class ArtistResponse {
  @Field(type => [Artist])
  artists: Artist[] =[];
  @Field((type) => Int, { nullable: false })
  total!: number;
}


@Resolver()
class ArtistResolver {

  //@Authorized("ADMIN")
  @Query((returns) => ArtistResponse, { nullable: true })
  async getArtists(@Ctx() { req, res, prisma }: Context, @Args() 
  { page, take }: ArtistArgs): Promise<ArtistResponse | null> {
    const artists = (await prisma.artist.findMany({
      take: take,
      skip: (page - 1) * take,
      orderBy: [
        {
          name: "asc"
        }
      ]
    }));

    const count = (await prisma.artist.count({

    }));
    return {artists: artists, total: count};
  }
}


export default ArtistResolver;

Answer 1

This is like my answer in Prisma js ORM - how to filter for results that have entry in a related table (effectively JOIN)?

To get only Artists that have at least one Track, you should use some and specify a condition that always return true for any related record that exists.

And if you want to your query includes related Tracks you must specify it in include property.

 await prisma.artist.findMany({
   where: {
     tracks: {
       some: {
         id: { not: "" } // It always should be true.
       },
     },
   },
   
   // if you want to include related tracks in returned object:
   include: {
     tracks: true,
   },
 });

Answer 2

You can use prisma OR and gt to filter artist who have at least one song track.

OR accept an arrary of conditions that must return true, while gt means value must be greater than x.