1

我有一个问题，谢谢任何帮助。

使用 prisma，我们可以将 include 与 where 条件一起用于具有关系的模型。如果我制定包含条件，我会得到正确的结果。如果我将它返回到前端，它会被覆盖。我想从后端返回准确的结果。

我在前端有一个查询（ApolloClient，gql）之类的。它将为每个帖子返回一组评论，我只想为每个帖子提供第一个评论。

const POSTS = gql`
    query posts {
        posts(postId: $postId) {
            id
            comments{ // at the backend I have conditions for the comments
              id
            }
        }
    }
`;

后端： Primsa 和 graphql nexus

棱镜模式

model Post {
  id            String         @id @default(cuid())
  comments      Comment[]
}

model Comment {
  id            String         @id @default(cuid())
  post          Post           @relation(fields: [postId], references: [id])
  postId        String
}

连结模型

const Post = objectType({
  name: 'Post',
  definition(t) {
    t.model.id()
    t.model.comments()
})

const Comment = objectType({
  name: 'Comment',
  definition(t) {
    t.model.id()
    t.model.post()
    t.model.postId()
})

解析器

export const posts = queryField('posts', {
  type: 'Post',
  list: true,
  args: {
    ...
  },
  resolve: async (_parent, args: any, { prisma, request }, info) => {
    
     const posts = await prisma.post.findMany({
      include: {
        comments: {
          take: 1
        }
      }
    })

    console.log(posts) 
    //Perfect result I want to return the include condition. But at the frontend I have all 
    //comments
    return posts
  },
})

console.log(posts) 正是我想要返回的内容！。每个帖子都有一个评论数组。我返回帖子，在前端每个帖子都有一个 ALL 评论数组，这是我不想要的。如何防止前端查询覆盖后端返回？字段是一样的。

4

3 回答 3

1

处理此问题的最佳方法是查询您使用我的PrismaSelect插件的前端请求。Prisma Select 采用info: GraphQLResolveInfo一般 graphql 参数（父、参数、上下文、信息）中的对象来选择接受的对象prisma client。该方法可以提供更好的性能，因为您将只使用一个解析器来检索您的所有请求。通过这样做，它也消除了这个N + 1问题。

此外，您可以使用我的 CLI 从您的 schema.prisma 文件https://paljs.com/generator/nexus中自动生成所有 CRUD

于 2020-10-04T11:16:01.117 回答
1

我无法添加评论，所以我将其添加到另一个答案中。

就像我对我的PrismaSelect插件所说的那样，你不能使用nexus-plugin-prisma t.model, t.crud。您将需要使用 Pal.Js CLI 为所有模型自动生成所有 CRUD 和 ObjectType。

const Post = objectType({
  name: 'Post',
  definition(t) {
    t.model.id()
    t.model.comments() // this field will overwritten by next one so this not needed
     t.list.field('comments', {
      type: 'Comment',
      list: true,
      resolve: (parent, args, { prisma }) => {
// here parent type include all other fields but not this field 
        return prisma.comment.findMany({ // this query is very wrong will case N+1 issue
          where: {
            postId: parent.id,
          },
          take: 1,
        })
      },
    })
})

例子

model User {
  id        Int       @default(autoincrement()) @id
  createdAt DateTime  @default(now())
  email     String    @unique
  name      String?
  password  String
  posts     Post[]
  comments  Comment[]
}

model Post {
  id        Int       @default(autoincrement()) @id
  published Boolean   @default(false)
  title     String
  author    User?     @relation(fields: [authorId], references: [id])
  authorId  Int?
  comments  Comment[]
}

model Comment {
  id        Int      @default(autoincrement()) @id
  contain   String
  post      Post     @relation(fields: [postId], references: [id])
  postId    Int
  author    User?    @relation(fields: [authorId], references: [id])
  authorId  Int?
}

这是我为 Post 模型生成的 Pal.Js CLI 类型

import { objectType } from '@nexus/schema'

export const Post = objectType({
  name: 'Post',
  definition(t) {
    t.int('id', { nullable: false })
    t.boolean('published', { nullable: false })
    t.string('title', { nullable: false })
    t.field('author', {
      nullable: true,
      type: 'User',
      resolve(parent: any) {
        return parent['author']
      },
    })
    t.int('authorId', { nullable: true })
    t.field('comments', {
      nullable: false,
      list: [true],
      type: 'Comment',
      args: {
        where: 'CommentWhereInput',
        orderBy: 'CommentOrderByInput',
        cursor: 'CommentWhereUniqueInput',
        take: 'Int',
        skip: 'Int',
        distinct: 'CommentDistinctFieldEnum',
      },
      resolve(parent: any) {
        return parent['comments']
      },
    })
  },
})

当您使用我的 Pal.js CLI 时，您的前端请求将是这样的

query {
  findOnePost(where: {id: 1}) {
   comments(where: {}, take: 1){
    id
   }
  }
}
``
于 2020-10-07T18:11:21.843 回答
0

我的意思是我可以在我的 Post-ObjectType 中添加一个字段条件，例如：

const Post = objectType({
  name: 'Post',
  definition(t) {
    t.model.id()
    t.model.comments()
     t.list.field('comments', {
      type: 'Comment',
      list: true,
      resolve: (parent, args, { prisma }) => {
        return prisma.comment.findMany({
          where: {
            postId: parent.id,
          },
          take: 1,
        })
      },
    })
})

这是有效的。但是，如果我理解正确的话，我会为每篇文章添加一个额外的请求。但是我已经在突变解析器上得到了正确的结果。而且我没有父级的评论字段（t.list.field-resolver）

于 2020-09-22T12:59:13.230 回答