graphql 数据增删改查分页及关联操作（三）

说明：

• 接第二篇文章，代码也是在第二篇文章之上
• 本文只是针对mondodb来操作

一、添加相关的包

• yarn add Mongoose

二、初始化Mongodb

• 修改server.ts
• 导入 import * as Mongoose from 'mongoose';
• 添加了方法 mongodbInit()
• 全部代码如下 ：

•  import * as express from 'express';
   const { graphqlExpress, graphiqlExpress } = require('apollo-server-express')
   const expressPlayground = require('graphql-playground-middleware-express').default;
   import * as Mongoose from 'mongoose';
   var bodyParser = require('body-parser');
   
   import schema from './schema';
   
   class Server {
       public app: express.Application;
       constructor() {
           this.app = express();
           this.routes();
           this.mongodbInit();
       }
   
       private routes(): void {
           this.app.use('/graphql',bodyParser.json(), graphqlExpress({ schema }));
           this.app.get('/playground', expressPlayground({ endpoint: '/graphql' }));
       }
   
       private mongodbInit() {
           const MONGO_URI = "mongodb://localhost/gqlServer";
           Mongoose.connect(MONGO_URI || process.env.MONGO_URI);
           this.app.use(bodyParser.urlencoded({ extended: false }));
           this.app.use(bodyParser.json());
       }
   }
   
   export default new Server().app;

三、修改user文件

• 添加user.ts代码如下：

•  import { model, Schema, Document } from 'mongoose';
   
   export interface IUserModel extends Document {
       id:string,
       name: String,
       password: String,
   }
   
   let UserSchema: Schema = new Schema({
       name: String,
       password: String,
       createAt: {
           type: Date,
           default: new Date(),
           required: true
       },
       updateAt: {
           type: Date,
           default: new Date(),
           required: true
       },
   })
   
   export default model<IUserModel>('User', UserSchema);

• 修改resolver.ts代码如下：

• import UserSchema, { IUserModel } from './user';
   
  export class User {
      constructor() {
   
      }
   
      static Query: any = {
          getUsers(parent, { }, context) {
              return UserSchema.find();
          }
      }
   
      static Mutation: any = {
          saveUser(parent, { user }, context) {
              return UserSchema.create(user)
          }
      }
   
  }

四、运行项目 yarn start 打开地址http://localhost:8080/playground应该可以添加用户和查找用户了效果如下：

五、增删改查相关的方法可以自己去扩展

六、关联

• 添加角色文件夹role/role.gql,role/resolve,role/resolver.ts
• 代码基本可以复制user里面的代码改相关的名字
• 项目结构
• role.gql代码

•  type Role{
       id:String
       roleName:String
   }
   
   extend type Query {
       # 查找所有角色
       getRoles: [Role]
   }
   
   extend type Mutation {
       # 创建角色| 修改角色
       saveRole(role:inputRole):Role
   }
   
   input inputRole{
       id:String
       roleName:String
   }

• role.ts代码

•  import { model, Schema, Document } from 'mongoose';
   
   export interface IRoleModel extends Document {
       id:string,
       roleMame: String,
   }
   
   let RoleSchema: Schema = new Schema({
       roleMame: String,
       createAt: {
           type: Date,
           default: new Date(),
           required: true
       },
       updateAt: {
           type: Date,
           default: new Date(),
           required: true
       },
   })
   
   export default model<IRoleModel>('Role', RoleSchema);

• resolver.ts 代码

•  import RoleSchema, { IRoleModel } from './role';
   
   export class Role {
       constructor() {
   
       }
   
       static Query: any = {
           getRoles(parent, { }, context) {
               return RoleSchema.find();
           }
       }
   
       static Mutation: any = {
           saveRole(parent, { role }, context) {
               return RoleSchema.create(role)
           }
       }
   
   }

• 导入resolver到resolvers.ts代码如下：

•  import { User } from "./user/resolver";
   import { Role } from "./role/resolver";
   
   export default {
       Query: {
           ...User.Query,
           ...Role.Query
       },
       Mutation: {
           ...User.Mutation,
           ...Role.Mutation
       },
   };

• 导入role.gql 到src/schema.ts 代码如下：

•  import { makeExecutableSchema } from 'graphql-tools';
   import resolver from "./resolvers";
   var requireText = require('require-text');
   var Base = requireText('./base.gql', require);
   var User = requireText('./user/user.gql', require);
   var Role = requireText('./role/role.gql', require); //添加了角色 
   
   //基础信息
   var typeDefs = [Base];
   typeDefs = typeDefs.concat(User);
   typeDefs = typeDefs.concat(Role);
   
   const schema = makeExecutableSchema({
     typeDefs: typeDefs,
     resolvers: resolver
   })
   
   export default schema; 

• 运行可以看到相关表，尝试添加一个角色，和查找一下

七、关联用户与角色，基本关系，每一个用户有一个角色1对1

• 修改文件user.gql代码如下：

•  type User{
       id:String
       name:String
       passwrod:String
       # 添加了role字段
       Role:Role
   }
   
   extend type Query {
       # 查找所有用户
       getUsers: [User]
   }
   
   extend type Mutation {
       # 创建用户|修改用户
       saveUser(user:inputUser):User
   }
   
   input inputUser{
       id:String
       name:String
       passwrod:String
       # 添加了roleid
       roleId:String
   }

• 修改user.ts文件代码如下：

•  import { model, Schema, Document } from 'mongoose';
   
   export interface IUserModel extends Document {
       id:string,
       name: String,
       passwrod: String,
       roleId: String,//只是添加了这里
   }
   
   let UserSchema: Schema = new Schema({
       name: String,
       passwrod: String,
       roleId: String, //只是添加了这里
       createAt: {
           type: Date,
           default: new Date(),
           required: true
       },
       updateAt: {
           type: Date,
           default: new Date(),
           required: true
       },
   })
   
   export default model<IUserModel>('User', UserSchema);

• 修改user/resolver.ts文件代码如下：

•  import UserSchema, { IUserModel } from './user';
   import RoleSchema from '../role/role';
   
   export class User {
       constructor() {
   
       }
   
       //只是添加用户的角色
       static User: any = {
           Role(model) {
               return RoleSchema.findById(model.roleId);
           },
       }
   
       static Query: any = {
           getUsers(parent, { }, context) {
               return UserSchema.find();
           }
       }
   
       static Mutation: any = {
           saveUser(parent, { user }, context) {
               return UserSchema.create(user)
           }
       }
   
   }

• 导入用户角色到resolver.ts代码如下：

•  import { User } from "./user/resolver";
   import { Role } from "./role/resolver";
   
   export default {
       Query: {
           ...User.Query,
           ...Role.Query
       },
       Mutation: {
           ...User.Mutation,
           ...Role.Mutation
       },
       User:User.User //只是添加了这一行
   };

• 运行，添加一个角色，根据角色id添加用户，页面查询应该可以看到以下结果：

八，相关的增加修改删除分页代码参考下面代码：

• user.gql

•  # 系统用户表
   type User {
       id: ID!
       # 用户登录名
       username: String
       # 姓名
       name: String
       # 邮件
       email:String
       # 密码
       password:String
       # 创建时间
       createAt:Date
       # 修改时间
       updateAt:Date
       #用户角色
       Role:Role
       #是否有效
       isValid:Boolean
       #用户资料
       Profile:Profile
   }
   
   extend type Query {
       # 查找所有用户
       getUsers: [User]
       # 根据ID查找用户
       getUserById(id:String):User
       # 分页查找
       getUserPage(pageIndex: Int, pageSize: Int,user:searchUser): [User]
       # 查找分页总数
       getUserCount(user:searchUser):Int
       # 根据条件查找
       getUserWhere(user:searchUser): [User]
       # 用户登录
       login (username:String!,password:String!): User
       # 用户退出
       logOut:Boolean,
       #当前登录用户
       currentUser:User
   
   }
   
   extend type Mutation {
       # 创建用户|修改用户
       saveUser(user:inputUser):User
        # 删除用户
       deleteUser(id:String):Boolean
   }
   
   input inputUser{
       id:String
       username: String
       name: String
       email:String
       password:String
       roleId:String
       profileId:String
       isValid:Boolean
   }
   
   input searchUser{
       username:Json
       roleId:Json
       email:Json
       name:Json
   }

• resolver.ts

   import UserSchema, { IUserModel } from './user';
   import RoleSchema from '../role/role';
   import ProfileSchema from '../profile/profile';
   
   import { DocumentQuery, MongoosePromise } from 'mongoose';
   
   export class User {
   
       constructor() {
       }
   
       static User: any = {
           Role(model) {
               return RoleSchema.findById(model.roleId);
           },
           Profile(model) {
               return ProfileSchema.findOne({ userId: model.id });
           }
       }
   
       static Query: any = {
           getUsers(parent, __, context): Promise<Array<IUserModel>> {
               //if (!context.user) return null;
               let promise = new Promise<Array<IUserModel>>((resolve, reject) => {
                   UserSchema.find().then(res => {
                       resolve(res);
                   }).catch(err => resolve(null));
               });
               return promise;
           },
   
           getUserById(parent, { id }, context): Promise<IUserModel> {
               //if (!context.user) return null;
   
               let promise = new Promise<IUserModel>((resolve, reject) => {
                   UserSchema.findById(id).then(res => {
                       resolve(res);
                   }).catch(err => resolve(null));
               });
               return promise;
           },
   
           getUserPage(parent, { pageIndex = 1, pageSize = 10, user }, context) {
               //if (!context.user) return null;
               var skip = (pageIndex - 1) * pageSize
               var userInfo = UserSchema.find(user).skip(skip).limit(pageSize)
               return userInfo;
           },
   
           getUserWhere(parent, { user }, context) {
               //if (!context.user) return null;
               console.log(user);
               var users = UserSchema.find(user);
               return users;
           },
   
           getUserCount(parent, { user }, context) {
               //if (!context.user) return 0;
               var count = UserSchema.count(user);
               return count;
           }, 
   
           login(parent, { username, password }, context) {
               return new Promise<any>((resolve, reject) => {
                   UserSchema.find({ username, password }).then(data => {
                       if (data.length > 0) {
                           var user=data[0];
                           context.session.user = user;
                           resolve(user);
                       } else {
                           context.session.user = null;
                           resolve(null);
                       }
                   })
               })
           },
           logOut(parent, { }, context) {
               context.user = null;
               context.session.user = null;
               return true;
           },
           currentUser(parent, { }, context) {
               //if (!context.user) return null;
               let promise = new Promise<IUserModel>((resolve, reject) => {
                   let user = context.user;
                   if (user) {
                       UserSchema.findById(user._id).then(res => {
                           resolve(res);
                       }).catch(err => resolve(null));
                   } else {
                       resolve(null);
                   }
               });
               return promise;
   
           },
       }
   
       static Mutation: any = {
           saveUser(parent, { user }, context) {
               //正式运行时请取消注释
               // if (!context.user) return null;
               if (user.id && user.id != "0") {
                   return new Promise<IUserModel>((resolve, reject) => {
                       UserSchema.findByIdAndUpdate(user.id, user, (err, res) => {
                           Object.assign(res, user);
                           resolve(res);
                       })
                   });
               }
               return UserSchema.create(user)
           },
   
           deleteUser(parent, { id }, context): Promise<Boolean> {
               //if (!context.user) return null;
               let promise = new Promise<Boolean>((resolve, reject) => {
                   UserSchema.findByIdAndRemove(id, (err, res) => {
                       resolve(res != null)
                   }).catch(err => reject(err));
               });
               return promise;
           }
       }
   }