Yes, you could query User data while fetching TeamMember information.

Consider this example:

schema.prisma

// This is your Prisma schema file,
// learn more about it in the docs: https://pris.ly/d/prisma-schema

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

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

model TeamMember {
  id      Int   @id @default(autoincrement())
  team_id Int
  User    User? @relation(fields: [userId], references: [id])
  userId  Int?
}

model User {
  id       Int          @id @default(autoincrement())
  name     String
  email    String
  password String
  team     TeamMember[]
}

index.ts

import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient({
  log: ['query'],
});

async function main() {
  await prisma.user.create({
    data: {
      email: 'test@test.com',
      name: 'test',
      password: 'test',
      team: {
        create: {
          team_id: 1,
        },
      },
    },
  });

  console.log('Created user');

  const teamWithUsers = await prisma.teamMember.findUnique({
    where: {
      id: 1,
    },
    include: {
      User: true,
    },
  });

  console.log('teamWithUsers', teamWithUsers);
}

main()
  .catch((e) => {
    throw e;
  })
  .finally(async () => {
    await prisma.$disconnect();
  });

Here's the response:

teamWithUsers {
  id: 1,
  team_id: 1,
  userId: 1,
  User: { id: 1, name: 'test', email: 'test@test.com', password: 'test' }
}

By default relation fields are not fetched, if you need to get the relation fields data in that case you would need to specify the include clause as demonstrated in the above example.

@atawfique21 👋
Yes currently two queries is the only way. We have a request for the same here that you can add a 👍 to and follow for more updates:
#7550

If it exists in findMany, it would still be 2 queries but yes the roundtrip to the database would just be 1.

I've found the solution here https://github.com/prisma/prisma/discussions/8216#discussioncomment-992302

It should be like this instead apparently.

await prisma.product.findMany({
      where: {
        AND: [
          { price: 21.99 },
          { filters: { some: { name: 'ram', value: '8GB' } } },
          { filters: { some: { name: 'storage', value: '256GB' } } },
        ],
      },
})

@ManishKarki1997 👋

I have tested this with random data and this works:

await prisma.product.findMany({
      where: {
        AND: [
          { price: 21.99 },
          { filters: { some: { name: 'ram', value: '8GB' } } },
          { filters: { some: { name: 'storage', value: '256GB' } } },
        ],
      },
})

From what I understand, there's 2 constraints that you need which isn't represented in your query right now.

1. Only return a user if the post inside posts_array is enabled.
2. Filter the returned posts of a user so that it only contains enabled posts.

I've updated your query to add these two conditions.

const users = await prisma.user.findMany({
    where: {
        enabled: true,
        posts: {
            some: {
                post_id: { in: posts_array },
                post: {  
                    enabled: true  // for constraint 1 (only check/match against the post_ids in post array which are enabled)
                }
            },
        },

    },

    include: {
        _count: { select: { posts: true } },
        posts: {
            select: { post: true },
            where: {
                post: {  
                    enabled: true   // for constraint 2 (only include the posts which are enabled)
                }
            }
        },
    },
})

Keep in mind that users[SOME_IDX]._count.posts will contain the count of ALL the posts of that user (including those which are disabled). If you want the count of enabled posts only, you will have to check the length of the users[SOME_IDX].posts array.

By the way, based on your schema, the user_to_post table is somewhat redundant. You could use an implicit many-to-many to model the relation between post and user.

That is not yet possible. Here's a GitHub issue that had been created you can use to monitor the feature's status and give your feedback too.

Could you also share your use case too? Your feedback will be highly appreciated as we relay it back to the team. 🙂