Query resolver result is different to server side log

[Nikxt]

Bug description

We are using a custom resolver to make a prisma query with a filter on a nested list. In this case, we query a Product with all related versions (filter: if version is not internal). This works like expected.

But in graphql playground we get the product with all versions (filter on related list ignored)

So our correct object is overwritten. It looks like there is just another hidden query right after our called query, which bypasses our filter.

How to reproduce

These are our two models:

model Product {
  id                              String             @default(cuid()) @id
  name                        String             @unique
  versionedProducts   VersionedProduct[]
}

model VersionedProduct {
  id                    String           @default(cuid()) @id
  isInternal        Boolean        @default(true)
  product          Product         @relation(fields: [productId], references: [id])
  productId       String
}

This is the query in our schema.ts:

    t.field("product", {
      type: "Product",
      nullable: true,
      args: {
        where: arg({ type: "ProductWhereUniqueInput", nullable: false })
      },
      resolve: async (parent, args, ctx, info) => {
        const product = await product(args, ctx);
        console.log(product .versionedProducts);
        return product 
      }
    });

1. We call the query from Graphql Playground.

2. [Server Side] We get the product with the correct filtered List of versions from Prisma.

3. [Server Side] We log the product.versions (listed in code block above) right before returning it inside resolve:

[
  {
    id: 'ck918rf4s00006cw988fa6bjv',
    isInternal: false
  },
  {
    id: 'ck8r6jdbo00199ow9xjlaynx2',
    isInternal: false
  }
]

4. We take a look on the result inside Playground:

The result is not correct anymore, because our server-side filter is ignored.

Expected behavior

The Result in Playground (4) and the server-side log (3) should be the same.

Environment & setup

Windows 10
Node v12.13.0

prisma/client: 2.0.0-beta.3
prisma/cli: 2.0.0-beta.3

nexus/schema": 0.13.1
nexus-plugin-prisma: 0.6.0

[Nikxt]

It looks like this is a more general problem, and we can reproduce this behavior on all types with a" one to many relation".

This example setup is a bit simpler

Types

One user can have many posts. Posts can be set to active or not active.

model TestUser {
  id    String @default(cuid()) @id
  posts Post[]
}

model Post {
  id       String   @default(cuid()) @id
  text     String
  isActive Boolean
  user     TestUser @relation(fields: [userId], references: [id])
  userId   String
}

Resolve function

Returning a user by id and include only active posts.

      resolve: async (parent, args, ctx, info) => {
        const testUser = await testUserWithActivePosts(args, ctx)
        console.log(testUser)
        return testUser
      }

export const testUserWithActivePosts = async () => {
  return ctx.prisma.testUser.findOne({where: args.where, include: {posts: {where: {isActive: true}}}})
};

Test data

In our database, we have:

• One User (id: test1)
• Two posts related to the User

post 1 isActive: true
post 2 isActive: false

Query execution with wrong result

If we call our query:

the server side console log is:

{
  id: 'test1',
  posts: [ { id: '000', text: 'Bye', isActive: true, userId: 'test1' } ]
}

The result in graphql playground is:

Expected behavior

Our final result in the playground should be the same as the primsa result inside our resolver. There should only be active posts.

[Bligoubloups]

Hello any update on this issue ?
I'm having same issue and can't find a way to solve it.

[Weakky]

Hey folks, this is presently not a bug and rather a misunderstanding of how nexus-plugin-prisma works.
Just because you're querying a relation on a parent resolver will not prevent a child resolvers from querying its own data. What happens is the following:

schema.objectType({
  name: 'User',
  definition(t) {
    t.model.id()
    t.model.products() <-- This field make its own query regardless of what's queried on the `Query.users` type
  }
})

schema.queryType({
  definition(t) {
    t.crud.users({
      resolve(root, args, ctx) {
		return ctx.db.users.findMany({ include: { products: { where: { /* some constraints */ } } } })
	  }
    })
  }
})

• Query.users make a query that includes the filtered products
• User.products make its own query again, regardless of the fact that products is already there

The constraint should rather be put on the child resolver and not the parent query. eg:

schema.objectType({
  name: 'User',
  definition(t) {
    t.model.id()
    t.model.products({
	  resolve(root, args, ctx) {
		return ctx.db.user.findOne({ where: { id: root.id } }).products({ where: { /* some constraints */ } })
      }
    })
  }
})

We could add some logic to not query the products if they're already coming from the parent (aka root param), unfortunately though, we would no longer be able to guarantee that the data coming from the parent fulfills the contract.

Hopefully that solves your issue 🙌