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;
          }
      }
  }