Nest.js中的GraphQL端点返回空对象

我正在使用Nest.js和Sequelize Typescript构建一个GraphQL API

当我调用delete和update时，我得到了一个null对象，但是操作完成了。我需要放置{nullable:true}，因为我得到一个错误，说

不能为非null字段返回null

。我怎么修理它？我需要端点返回更新的对象，以便在前面显示信息

book.dto.ts

book.resolver.ts

从'@nestjs/graphql'导入{Args，Mutation，Query，Resolver}；
从“./model/Book.entity”导入{Book}；
从“./dto/book.dto”导入{BookType}；
从“./input/createBook.input”导入{CreateBookInput}；
从“./input/updateBook.input”导入{UpdateBookInput}；
从“/book.service”导入{BookService}；
@解析程序（'Book'）
导出类图书解析程序{
构造函数（私有只读bookService:bookService）{}
@查询（（）=>[BookType]）
异步getAll（）：承诺{
return等待这个。bookService.findAll（）；
}
@查询（（）=>BookType）
异步getOne（@Args（'id'）id:number）{
返回等待此。bookService.find（id）；
}
@突变（（）=>BookType）
异步createItem（@Args（'input'）输入：CreateBookInput）：承诺{
const book=新书（）；
book.author=input.author；
book.title=input.title；
返回等待此。bookService。创建（book）；
}
@突变（（）=>BookType）
异步更新项(
@Args（'input'）输入：UpdateBookInput）：承诺{
返回等待此.bookService.update（输入）；
}
@突变（（）=>BookType）
异步删除项（@Args（'id'）id:number）{
返回等待此.bookService.delete（id）；
}
@查询（（）=>字符串）
异步hello（）{
返回“你好”；
}
}

图书服务

从'@nestjs/common'导入{Inject，Injectable}；
从'@nestjs/typeorm'导入{InjectRepository}；
从“./model/Book.entity”导入{Book}；
从“typeorm”导入{DeleteResult，InsertResult，Repository，UpdateResult}；
@可注射（）
出口类图书服务{
构造函数（@Inject（'BOOKS_REPOSITORY'）私有只读bookRepository:typeof Book）{}
承诺{
返回此.bookRepository.findAll（）；
}
发现（id）：承诺{
返回this.bookRepository.findOne（{where:{id}}）；
}
创建（数据）：承诺{
返回data.save（）；
}
更新（数据）：承诺{
返回this.bookRepository.update（数据，{where:{id:data.id}}）；
}
删除（id）：承诺{
返回this.bookRepository.destroy（{where:{id}}）；
}
}

为什么要从删除中返回这些字段？你的前端一定已经有了它们。。。你可以根据它是否有效，将该突变的返回类型更改为真或假。。。在更新中，如果您使用postgres，您可以进行变异并在选项中添加returning:true。。。如果没有，则不返回更新结果，执行更新并返回findOne或findById的结果（以适用者为准）

您可以在解析器查询中修复它设置选项参数

@Query(() => BookType, { nullable: true })

import {Args, Mutation, Query, Resolver} from '@nestjs/graphql';
import { Book } from './model/book.entity';
import { BookType } from './dto/book.dto';
import { CreateBookInput } from './input/createBook.input';
import { UpdateBookInput } from './input/updateBook.input';
import { BookService } from './book.service';

@Resolver('Book')
export class BookResolver {
    constructor(private readonly bookService: BookService) {}

    @Query(() => [BookType])
    async getAll(): Promise<BookType[]> {
        return await this.bookService.findAll();
    }

    @Query(() => BookType)
    async getOne(@Args('id') id: number) {
        return await this.bookService.find(id);
    }

    @Mutation(() => BookType)
    async createItem(@Args('input') input: CreateBookInput): Promise<Book> {
        const book = new Book();
        book.author = input.author;
        book.title = input.title;
        return await this.bookService.create(book);
    }

    @Mutation(() => BookType)
    async updateItem(
        @Args('input') input: UpdateBookInput): Promise<[number, Book[]]> {
        return await this.bookService.update(input);
    }

    @Mutation(() => BookType)
    async deleteItem(@Args('id') id: number) {
        return await this.bookService.delete(id);
    }

    @Query(() => String)
    async hello() {
        return 'hello';
    }
}

import {Inject, Injectable} from '@nestjs/common';
import {InjectRepository} from '@nestjs/typeorm';
import {Book} from './model/book.entity';
import {DeleteResult, InsertResult, Repository, UpdateResult} from 'typeorm';

@Injectable()
export class BookService {
    constructor(@Inject('BOOKS_REPOSITORY') private readonly bookRepository: typeof Book) {}

    findAll(): Promise<Book[]> {
        return this.bookRepository.findAll<Book>();
    }

    find(id): Promise<Book> {
       return this.bookRepository.findOne({where: {id}});
    }

    create(data): Promise<Book> {
        return data.save();
    }

    update(data): Promise<[number, Book[]]> {
        return this.bookRepository.update<Book>(data, { where: {id: data.id} });
    }

    delete(id): Promise<number> {
        return this.bookRepository.destroy({where: {id}});
    }
}

@Query(() => BookType, { nullable: true })