在线时间:8:00-16:00
迪恩网络APP
随时随地掌握行业动态
扫描二维码
关注迪恩网络微信公众号
开源软件名称(OpenSource Name):moleculerjs/moleculer-apollo-server开源软件地址(OpenSource Url):https://github.com/moleculerjs/moleculer-apollo-server开源编程语言(OpenSource Language):JavaScript 100.0%开源软件介绍(OpenSource Introduction):moleculer-apollo-serverApollo GraphQL server mixin for Moleculer API Gateway FeaturesInstall
UsageThis example demonstrates how to setup a Moleculer API Gateway with GraphQL mixin in order to handle incoming GraphQL requests via the default "use strict";
const ApiGateway = require("moleculer-web");
const { ApolloService } = require("moleculer-apollo-server");
module.exports = {
name: "api",
mixins: [
// Gateway
ApiGateway,
// GraphQL Apollo Server
ApolloService({
// Global GraphQL typeDefs
typeDefs: ``,
// Global resolvers
resolvers: {},
// API Gateway route options
routeOptions: {
path: "/graphql",
cors: true,
mappingPolicy: "restrict"
},
// https://www.apollographql.com/docs/apollo-server/v2/api/apollo-server.html
serverOptions: {
tracing: true,
engine: {
apiKey: process.env.APOLLO_ENGINE_KEY
}
}
})
]
}; Start your Moleculer project, open http://localhost:3000/graphql in your browser to run queries using graphql-playground, or send GraphQL requests directly to the same URL. Define queries & mutations in service action definitions module.exports = {
name: "greeter",
actions: {
hello: {
graphql: {
query: "hello: String"
},
handler(ctx) {
return "Hello Moleculer!"
}
},
welcome: {
params: {
name: "string"
},
graphql: {
mutation: "welcome(name: String!): String"
},
handler(ctx) {
return `Hello ${ctx.params.name}`;
}
}
}
}; Generated schema type Mutation {
welcome(name: String!): String
}
type Query {
hello: String
} Resolvers between servicesposts.service.js module.exports = {
name: "posts",
settings: {
graphql: {
type: `
"""
This type describes a post entity.
"""
type Post {
id: Int!
title: String!
author: User!
votes: Int!
voters: [User]
createdAt: Timestamp
}
`,
resolvers: {
Post: {
author: {
// Call the `users.resolve` action with `id` params
action: "users.resolve",
rootParams: {
"author": "id"
}
},
voters: {
// Call the `users.resolve` action with `id` params
action: "users.resolve",
rootParams: {
"voters": "id"
}
}
}
}
}
},
actions: {
find: {
//cache: true,
params: {
limit: { type: "number", optional: true }
},
graphql: {
query: `posts(limit: Int): [Post]`
},
handler(ctx) {
let result = _.cloneDeep(posts);
if (ctx.params.limit)
result = posts.slice(0, ctx.params.limit);
else
result = posts;
return _.cloneDeep(result);
}
},
findByUser: {
params: {
userID: "number"
},
handler(ctx) {
return _.cloneDeep(posts.filter(post => post.author == ctx.params.userID));
}
},
}
}; users.service.js module.exports = {
name: "users",
settings: {
graphql: {
type: `
"""
This type describes a user entity.
"""
type User {
id: Int!
name: String!
birthday: Date
posts(limit: Int): [Post]
postCount: Int
}
`,
resolvers: {
User: {
posts: {
// Call the `posts.findByUser` action with `userID` param.
action: "posts.findByUser",
rootParams: {
"id": "userID"
}
},
postCount: {
// Call the "posts.count" action
action: "posts.count",
// Get `id` value from `root` and put it into `ctx.params.query.author`
rootParams: {
"id": "query.author"
}
}
}
}
}
},
actions: {
find: {
//cache: true,
params: {
limit: { type: "number", optional: true }
},
graphql: {
query: "users(limit: Int): [User]"
},
handler(ctx) {
let result = _.cloneDeep(users);
if (ctx.params.limit)
result = users.slice(0, ctx.params.limit);
else
result = users;
return _.cloneDeep(result);
}
},
resolve: {
params: {
id: [
{ type: "number" },
{ type: "array", items: "number" }
]
},
handler(ctx) {
if (Array.isArray(ctx.params.id)) {
return _.cloneDeep(ctx.params.id.map(id => this.findByID(id)));
} else {
return _.cloneDeep(this.findByID(ctx.params.id));
}
}
}
}
}; File Uploadsmoleculer-apollo-server supports file uploads through the GraphQL multipart request specification. To enable uploads, the Upload scalar must be added to the Gateway: "use strict";
const ApiGateway = require("moleculer-web");
const { ApolloService, GraphQLUpload } = require("moleculer-apollo-server");
module.exports = {
name: "api",
mixins: [
// Gateway
ApiGateway,
// GraphQL Apollo Server
ApolloService({
// Global GraphQL typeDefs
typeDefs: ["scalar Upload"],
// Global resolvers
resolvers: {
Upload: GraphQLUpload
},
// API Gateway route options
routeOptions: {
path: "/graphql",
cors: true,
mappingPolicy: "restrict"
},
// https://www.apollographql.com/docs/apollo-server/v2/api/apollo-server.html
serverOptions: {
tracing: true,
engine: {
apiKey: process.env.APOLLO_ENGINE_KEY
}
}
})
]
}; Then a mutation can be created which accepts an Upload argument. The files.service.js module.exports = {
name: "files",
settings: {
graphql: {
type: `
"""
This type describes a File entity.
"""
type File {
filename: String!
encoding: String!
mimetype: String!
}
`
}
},
actions: {
uploadFile: {
graphql: {
mutation: "uploadFile(file: Upload!): File!",
fileUploadArg: "file",
},
async handler(ctx) {
const fileChunks = [];
for await (const chunk of ctx.params) {
fileChunks.push(chunk);
}
const fileContents = Buffer.concat(fileChunks);
// Do something with file contents
// Additional arguments:
this.logger.info("Additional arguments:", ctx.meta.$args);
return ctx.meta.$fileInfo;
}
}
}
}; To accept multiple uploaded files in a single request, the mutation can be changed to accept an array of ...
graphql: {
mutation: "upload(file: [Upload!]!): [File!]!",
fileUploadArg: "file"
}
... Dataloadermoleculer-apollo-server supports DataLoader via configuration in the resolver definition. The called action must be compatible with DataLoader semantics -- that is, it must accept params with an array property and return an array of the same size, with the results in the same order as they were provided. To activate DataLoader for a resolver, simply add settings: {
graphql: {
resolvers: {
Post: {
author: {
action: "users.resolve",
dataLoader: true,
rootParams: {
author: "id",
},
},
voters: {
action: "users.resolve",
dataLoader: true,
rootParams: {
voters: "id",
},
},
... Since DataLoader only expects a single value to be loaded at a time, only one You can also specify options for construction of the DataLoader in the called action definition's resolve: {
params: {
id: [{ type: "number" }, { type: "array", items: "number" }],
graphql: { dataLoaderOptions: { maxBatchSize: 100 } },
},
handler(ctx) {
this.logger.debug("resolve action called.", { params: ctx.params });
if (Array.isArray(ctx.params.id)) {
return _.cloneDeep(ctx.params.id.map(id => this.findByID(id)));
} else {
return _.cloneDeep(this.findByID(ctx.params.id));
}
},
}, It is unlikely that setting any of the options which accept a function will work properly unless you are running moleculer in a single-node environment. This is because the functions will not serialize and be run by the moleculer-web Api Gateway. Examples
Test
In development with watching
ContributionPlease send pull requests improving the usage and fixing bugs, improving documentation and providing better examples, or providing some testing, because these things are important. LicenseThe project is available under the MIT license. ContactCopyright (c) 2020 MoleculerJS |
2023-10-27
2022-08-15
2022-08-17
2022-09-23
2022-08-13
请发表评论