在mongodb模型中添加对象到对象数组

Question

我制作了一个GraphQL API来检索和操作mongo数据库中的数据。此数据表示一个作者，其中包含如Author.ts中所示的书籍列表。

Author.ts:

import { Document, Model, model, Schema } from "mongoose";
import { Ibook } from "./book";

export interface Iauthor extends Document {
    name: String;
    books: Array<Ibook>;
  }
  
const AuthorSchema: Schema = new Schema({
    name: { type: String, required: true },
    books: { type: Array, required: true }
  });
  
export const Author: Model<Iauthor> = model('author', AuthorSchema);

Book.ts:

import {Document, Model, model, Schema} from "mongoose";

export interface Ibook extends Document {
    title: String;
    pages: Number;
  }
  
const BookSchema: Schema = new Schema({
    title: { type: String, required: true },
    pages: { type: Number, required: true }
  });
  
export const Book: Model<Ibook> = model('book', BookSchema);

我使用查询解析器和变异解析器来读取和操作这些对象。我只是迁移到graphql-复合-猫鼬来生成解析器，而不是自己编程。在遇到解析器"AssignBooktoAuthor“之前，我成功地迁移了每个查询和突变。这基本上是一个解析器，它将图书对象添加到作者图书列表中。我只是不知道如何使它与graphql-组合-猫鼬一起工作。

composer.ts:

import { composeMongoose } from "graphql-compose-mongoose";
import { schemaComposer } from "graphql-compose";
import { Book } from "./models/book";
import { Author } from "./models/author";

const customizationOptions = {};
const BookTC = composeMongoose(Book, customizationOptions);
const AuthorTC = composeMongoose(Author, customizationOptions);

//in aparte file zetten prob
schemaComposer.Query.addFields({
  getAllBooks: BookTC.mongooseResolvers.findMany(),
  getBookById: BookTC.mongooseResolvers.findById(),
  getAllAuthors: AuthorTC.mongooseResolvers.findMany(),
  getAuthorById: AuthorTC.mongooseResolvers.findById(),
});

schemaComposer.Mutation.addFields({
  CreateBook: BookTC.mongooseResolvers.createOne(),
  UpdateBook: BookTC.mongooseResolvers.updateById(),
  DeleteBook: BookTC.mongooseResolvers.removeById(),
  CreateAuthor: AuthorTC.mongooseResolvers.createOne(),
  UpdateAuthor: AuthorTC.mongooseResolvers.updateById(),
  DeleteAuthor: AuthorTC.mongooseResolvers.removeById(),
  /**AssignBooktoAuthor: AuthorTC.mongooseResolvers.///What function does this??///**/
});

const graphqlSchema = schemaComposer.buildSchema();
export default graphqlSchema;

gql.ts (服务器文件)：

import { ApolloServer, gql } from "apollo-server-express";
import * as mongoose from "mongoose";
import * as express from "Express";
import * as dotenv from "dotenv";
import * as jwt from "jsonwebtoken";
import graphqlSchema from "./composer";

const app = express();
 
dotenv.config();

(async () => {
  mongoose.connect("mongodb+srv://xxxxxxx:xxxxxxx@clusterxxxxx.mongodb.net/myFirstDatabase?retryWrites=true&w=majority", { useUnifiedTopology: true , useNewUrlParser: true});

  const server = new ApolloServer({ 
    schema: graphqlSchema,
  });

  await server.start();

  //verifying token 
  app.use((req, res, next) => {
    const Token = req.header('auth-token');
    try{
      (Token && jwt.verify(Token, process.env.TOKEN_SECRET)) ? next() : console.log("mw: Unauthorized");
    }catch(err){
      console.log("mw:Unauthorized");
    }
  });

  server.applyMiddleware({ app });
  
  app.listen({ port: 4000 }, () =>
  console.log(` Server ready at http://localhost:4000${server.graphqlPath}`)
  );

})();

既然图形on合成猫鼬的支持没有那么大，我希望有人能帮助我解决这个问题！

Answer 1

我自己找到了解决办法！

Graphql支持使用按对象id添加关系。因此，在模型中，您必须分配一个名为authorid的类型，然后用objectid类型添加一个"ref“。例如，请参见book.ts。有关addrelation示例，请参见composer.ts。

Book.ts:

export interface Ibook extends Document {
  title: String;
  pages: Number;
  author: Schema.Types.ObjectId; 
}
  
const BookSchema: Schema = new Schema({
  title: { type: String, required: true },
  pages: { type: Number, required: true },
  author: { type: Schema.Types.ObjectId, ref:"author", required: true}
});

Composer.ts:

BookTC.addRelation('author', {
  resolver: () => AuthorTC.mongooseResolvers.findById(),
  prepareArgs:{
    _id: source => source.author,
    skip: null,
    sort: null,    
  },
  projection: {author: true},
})

AuthorTC.addRelation('books', {
  resolver: () => BookTC.mongooseResolvers.findMany(),
  prepareArgs: {
    filter: source => ({ author: source._id }),
  },
  projection: { id: true },
});