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

68 阅读 0 评论 45 点赞

我是靠谱客的博主孤独花卷，最近开发中收集的这篇文章主要介绍graphql 数据增删改查分页及关联操作（三），觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

说明：

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

一、添加相关的包

yarn add Mongoose

二、初始化Mongodb

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

 1 import * as express from 'express';
 2 const { graphqlExpress, graphiqlExpress } = require('apollo-server-express')
 3 const expressPlayground = require('graphql-playground-middleware-express').default;
 4 import * as Mongoose from 'mongoose';
 5 var bodyParser = require('body-parser');
 6
 7 import schema from './schema';
 8
 9 class Server {
10 
public app: express.Application;
11 
constructor() {
12
this.app = express();
13
this.routes();
14
this.mongodbInit();
15 
}
16
17
private routes(): void {
18
this.app.use('/graphql',bodyParser.json(), graphqlExpress({ schema }));
19
this.app.get('/playground', expressPlayground({ endpoint: '/graphql' }));
20 
}
21
22 
private mongodbInit() {
23
const MONGO_URI = "mongodb://localhost/gqlServer";
24
Mongoose.connect(MONGO_URI || process.env.MONGO_URI);
25
this.app.use(bodyParser.urlencoded({ extended: false }));
26
this.app.use(bodyParser.json());
27 
}
28 }
29
30 export default new Server().app;

三、修改user文件

添加user.ts代码如下：

 1 import { model, Schema, Document } from 'mongoose';
 2
 3 export interface IUserModel extends Document {
 4 
id:string,
 5 
name: String,
 6 
password: String,
 7 }
 8
 9 let UserSchema: Schema = new Schema({
10 
name: String,
11 
password: String,
12 
createAt: {
13 
type: Date,
14
default: new Date(),
15
required: true
16 
},
17 
updateAt: {
18 
type: Date,
19
default: new Date(),
20
required: true
21 
},
22 })
23
24 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代码

 1 type Role{
 2 
id:String
 3 
roleName:String
 4 }
 5
 6
 7 extend type Query {
 8 
# 查找所有角色
 9 
getRoles: [Role]
10 }
11
12 extend type Mutation {
13
# 创建角色| 修改角色
14 
saveRole(role:inputRole):Role
15 }
16
17 input inputRole{
18 
id:String
19 
roleName:String
20 }

role.ts代码

 1 import { model, Schema, Document } from 'mongoose';
 2
 3 export interface IRoleModel extends Document {
 4 
id:string,
 5 
roleMame: String,
 6 }
 7
 8 let RoleSchema: Schema = new Schema({
 9 
roleMame: String,
10 
createAt: {
11 
type: Date,
12
default: new Date(),
13
required: true
14 
},
15 
updateAt: {
16 
type: Date,
17
default: new Date(),
18
required: true
19 
},
20 })
21
22 export default model<IRoleModel>('Role', RoleSchema);

resolver.ts 代码

 1 import RoleSchema, { IRoleModel } from './role';
 2
 3 export class Role {
 4 
constructor() {
 5
 6 
}
 7
 8
static Query: any = {
 9 
getRoles(parent, { }, context) {
10
return RoleSchema.find();
11 
}
12 
}
13
14
static Mutation: any = {
15 
saveRole(parent, { role }, context) {
16
return RoleSchema.create(role)
17 
}
18 
}
19
20 }

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

 1 import { User } from "./user/resolver";
 2 import { Role } from "./role/resolver";
 3
 4 export default {
 5 
Query: {
 6 
...User.Query,
 7 
...Role.Query
 8 
},
 9 
Mutation: {
10 
...User.Mutation,
11 
...Role.Mutation
12 
},
13 };

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

 1 import { makeExecutableSchema } from 'graphql-tools';
 2 import resolver from "./resolvers";
 3 var requireText = require('require-text');
 4 var Base = requireText('./base.gql', require);
 5 var User = requireText('./user/user.gql', require);
 6 var Role = requireText('./role/role.gql', require); //添加了角色 
 7
 8
 9 //基础信息
10 var typeDefs = [Base];
11 typeDefs = typeDefs.concat(User);
12 typeDefs = typeDefs.concat(Role);
13
14 const schema = makeExecutableSchema({
15 
typeDefs: typeDefs,
16 
resolvers: resolver
17 })
18
19
20 export default schema;

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

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

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

 1 type User{
 2 
id:String
 3 
name:String
 4 
passwrod:String
 5 
# 添加了role字段
 6 
Role:Role
 7 }
 8
 9
10 extend type Query {
11 
# 查找所有用户
12 
getUsers: [User]
13 }
14
15 extend type Mutation {
16
# 创建用户|修改用户
17 
saveUser(user:inputUser):User
18 }
19
20 input inputUser{
21 
id:String
22 
name:String
23 
passwrod:String
24 
# 添加了roleid
25 
roleId:String
26 }

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

 1 import { model, Schema, Document } from 'mongoose';
 2
 3 export interface IUserModel extends Document {
 4 
id:string,
 5 
name: String,
 6 
passwrod: String,
 7
roleId: String,//只是添加了这里
 8 }
 9
10 let UserSchema: Schema = new Schema({
11 
name: String,
12 
passwrod: String,
13
roleId: String, //只是添加了这里
14 
createAt: {
15 
type: Date,
16
default: new Date(),
17
required: true
18 
},
19 
updateAt: {
20 
type: Date,
21
default: new Date(),
22
required: true
23 
},
24 })
25
26 export default model<IUserModel>('User', UserSchema);

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

 1 import UserSchema, { IUserModel } from './user';
 2 import RoleSchema from '../role/role';
 3
 4 export class User {
 5 
constructor() {
 6
 7 
}
 8
 9
 //只是添加用户的角色
10
static User: any = {
11 
Role(model) {
12
return RoleSchema.findById(model.roleId);
13 
},
14 
}
15
16
static Query: any = {
17 
getUsers(parent, { }, context) {
18
return UserSchema.find();
19 
}
20 
}
21
22
static Mutation: any = {
23 
saveUser(parent, { user }, context) {
24
return UserSchema.create(user)
25 
}
26 
}
27
28 }

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

 1 import { User } from "./user/resolver";
 2 import { Role } from "./role/resolver";
 3
 4 export default {
 5 
Query: {
 6 
...User.Query,
 7 
...Role.Query
 8 
},
 9 
Mutation: {
10 
...User.Mutation,
11 
...Role.Mutation
12 
},
13
User:User.User //只是添加了这一行
14 };

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

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

user.gql

 1 # 系统用户表
 2 type User {
 3
id: ID!
 4 
# 用户登录名
 5 
username: String
 6 
# 姓名
 7 
name: String
 8 
# 邮件
 9 
email:String
10 
# 密码
11 
password:String
12 
# 创建时间
13 
createAt:Date
14 
# 修改时间
15 
updateAt:Date
16 
#用户角色
17 
Role:Role
18 
#是否有效
19 
isValid:Boolean
20 
#用户资料
21 
Profile:Profile
22 }
23
24 extend type Query {
25 
# 查找所有用户
26 
getUsers: [User]
27 
# 根据ID查找用户
28 
getUserById(id:String):User
29 
# 分页查找
30 
getUserPage(pageIndex: Int, pageSize: Int,user:searchUser): [User]
31 
# 查找分页总数
32 
getUserCount(user:searchUser):Int
33 
# 根据条件查找
34 
getUserWhere(user:searchUser): [User]
35 
# 用户登录
36
login (username:String!,password:String!): User
37 
# 用户退出
38 
logOut:Boolean,
39 
#当前登录用户
40 
currentUser:User
41
42 }
43
44 extend type Mutation {
45
# 创建用户|修改用户
46 
saveUser(user:inputUser):User
47 
# 删除用户
48 
deleteUser(id:String):Boolean
49 }
50
51 input inputUser{
52 
id:String
53 
username: String
54 
name: String
55 
email:String
56 
password:String
57 
roleId:String
58 
profileId:String
59 
isValid:Boolean
60 }
61
62 input searchUser{
63 
username:Json
64 
roleId:Json
65 
email:Json
66 
name:Json
67 }

View Code

resolver.ts


1 import UserSchema, { IUserModel } from './user';

2 import RoleSchema from '../role/role';

3 import ProfileSchema from '../profile/profile';

4

5

6 import { DocumentQuery, MongoosePromise } from 'mongoose';

7

8 export class User {

9
 10
 11 
constructor() {
 12 
}
 13
 14
static User: any = {
 15 
Role(model) {
 16
return RoleSchema.findById(model.roleId);
 17 
},
 18 
Profile(model) {
 19
return ProfileSchema.findOne({ userId: model.id });
 20 
}
 21 
}
 22
 23
static Query: any = {
 24
getUsers(parent, __, context): Promise<Array<IUserModel>> {
 25
//if (!context.user) return null;
 26
let promise = new Promise<Array<IUserModel>>((resolve, reject) => {
 27
UserSchema.find().then(res => {
 28 
resolve(res);
 29
}).catch(err => resolve(null));
 30 
});
 31
return promise;
 32 
},
 33
 34
getUserById(parent, { id }, context): Promise<IUserModel> {
 35
//if (!context.user) return null;
 36
 37
let promise = new Promise<IUserModel>((resolve, reject) => {
 38
UserSchema.findById(id).then(res => {
 39 
resolve(res);
 40
}).catch(err => resolve(null));
 41 
});
 42
return promise;
 43 
},
 44
 45
getUserPage(parent, { pageIndex = 1, pageSize = 10, user }, context) {
 46
//if (!context.user) return null;
 47
var skip = (pageIndex - 1) * pageSize
 48
var userInfo = UserSchema.find(user).skip(skip).limit(pageSize)
 49
return userInfo;
 50 
},
 51
 52 
getUserWhere(parent, { user }, context) {
 53
//if (!context.user) return null;
 54 
console.log(user);
 55
var users = UserSchema.find(user);
 56
return users;
 57 
},
 58
 59 
getUserCount(parent, { user }, context) {
 60
//if (!context.user) return 0;
 61
var count = UserSchema.count(user);
 62
return count;
 63 
},
 64
 65 
login(parent, { username, password }, context) {
 66
return new Promise<any>((resolve, reject) => {
 67
UserSchema.find({ username, password }).then(data => {
 68
if (data.length > 0) {
 69
var user=data[0];
 70
context.session.user = user;
 71 
resolve(user);
 72
} else {
 73
context.session.user = null;
 74
resolve(null);
 75 
}
 76 
})
 77 
})
 78 
},
 79 
logOut(parent, { }, context) {
 80
context.user = null;
 81
context.session.user = null;
 82
return true;
 83 
},
 84 
currentUser(parent, { }, context) {
 85
//if (!context.user) return null;
 86
let promise = new Promise<IUserModel>((resolve, reject) => {
 87
let user = context.user;
 88
if (user) {
 89
UserSchema.findById(user._id).then(res => {
 90 
resolve(res);
 91
}).catch(err => resolve(null));
 92
} else {
 93
resolve(null);
 94 
}
 95 
});
 96
return promise;
 97
 98 
},
 99 
}
100
101
static Mutation: any = {
102 
saveUser(parent, { user }, context) {
103
//正式运行时请取消注释
104
// if (!context.user) return null;
105
if (user.id && user.id != "0") {
106
return new Promise<IUserModel>((resolve, reject) => {
107
UserSchema.findByIdAndUpdate(user.id, user, (err, res) => {
108 
Object.assign(res, user);
109 
resolve(res);
110 
})
111 
});
112 
}
113
return UserSchema.create(user)
114 
},
115
116
deleteUser(parent, { id }, context): Promise<Boolean> {
117
//if (!context.user) return null;
118
let promise = new Promise<Boolean>((resolve, reject) => {
119
UserSchema.findByIdAndRemove(id, (err, res) => {
120
resolve(res != null)
121
}).catch(err => reject(err));
122 
});
123
return promise;
124 
}
125 
}
126 }