Meteor GraphQL RxJs Integration suite
npm install meteor-graphql-rxjsmeteor-graphql-rxjs
==
GraphQL-RxJS Integration package for Meteor
This package is used along with meteor-rxjs to enable reactive graphql
experiance for meteor.
#### Quick Start
- Mongo Collections:
Mongo Collections needs to be initialized using meteor-rxjs wrapper,
this way Collection.find will return an RxJs Observable:
``typescript
import { MongoObservable } from 'meteor-rxjs';
export interface Message {
from: String
content: String
}
export const Messages = new MongoObservable.Collection
`Observable
- Schema:
GraphQL-RxJS adds support for graphql resolvers,`
also, resolvers are running under meteor invocation.
typescript
import { makeExecutableSchema } from 'graphql-tools';
export const schema = makeExecutableSchema({
typeDefs:
type Message {
content: String
}
type Query {
allMessages: [Message]
}
type Mutation {
addMessage(content: String!): Boolean
}
,`
resolvers: {
Query: {
allMessages: (root, args, ctx) => {
return ctx.Messages.find({});
},
},
Mutation: {
addMessage: (root, args, ctx) => {
if ( !this.userId ) {
throw new Error('Not logged in');
}
ctx.Messages.collection.insert({
from: this.userId,
content: args.content,
});
return true;
},
},
},
});
`
- Server Side:
Server side needs to be initialized by just providing a schema and a context:
typescript
import { runGraphQLServer } from 'meteor-graphql-rxjs';
import { schema } from './schema';
import { Messages } from './collections/messages';
Meteor.startup(() => {
const sub = runGraphQLServer(Npm.require, {
schema,
createContext: (payload) => ({
Messages,
}),
})
.subscribe(undefined, (error) => {
console.error('GraphQL Server Failed:', error);
});
});
`/graphql
at this point, you should have 2 new endpoints in your graphql server:
- - websocket graphql endpoint./graphiql
- - GraphiQL Interface connected to that endpoint. (Only if graphiql option = true)
- Client Side:
Client can just import a connected network interface:
`typescript`
import { getNetworkInterface } from 'meteor-graphql-rxjs';
const networkInterface = getNetworkInterface();
// ...
// you can now use this networkInterface to send graphql requests,
// or provide it for apollo client for example.
#### API
- Client:
- function getNetworkInterface(params?: ClientOptions): SubscriptionsClient - This function will return aparams
connected network interface that you can just send requests through or pass to apollo-client for example.
- -> optional extra params for SubscriptionsClientrunGraphQLServer(mRequire: MeteorRequire, options: GraphQLServerOptions): Observable
- Server:
- - This function will return an Observable. subscribing on this observable will start the server.mRequire
- -> Meteor's Npm.Require function.options
- -> actual server options:schema
- -> Required Parameter with GraphQLSchema to execute.createContext: (initPayload: any)
- -> Optional callback to provide context per session.connect
initPayload will contain connection payload.quiet
- -> Optional boolean to disable info prints.graphiql
- -> Optional boolean to enable graphiql.graphiqlQuery
- -> Optional string containing default document for GraphiQL.
#### Settings
this package works with Meteor's settings
all you need to do is add meteor-graphql-rxjs key, for example:`json`
{
"meteor-graphql-rxjs": {
"graphqlEndpoint": "/graphql",
"graphiqlEndpoint": "/graphiql"
}
}
Available options:
- graphqlEndpoint: path for graphql websocket endpointgraphiqlEndpoint
- : path for graphiql interface (incase graphiql = true)
#### Resolver's Context
resolvers will be executed under Meteor's invocation, which means you can use:
1. this.userId => Same as this.userId inside any other invocation.this.call(methodName, ...args)
2. => invoke Meteor method and return promise for the result.this.userId$
3. => Observable with userId, for example:`
typescript
import { makeExecutableSchema } from 'graphql-tools';
export const schema = makeExecutableSchema({
typeDefs:
type Message {
content: String
}
type Query {
myMessage: [Message]
}
,`
resolvers: {
Query: {
myMessage: (root, args, ctx) => {
return this.userId$.switchMap((userId) => {
if ( !userId ) {
return Observable.of(null);
}
return ctx.Messages.find({ from: userId });
});
},
},
},
});
#### Extentions
This package also bring extentions with it,
the extentions should connect between Meteor's world into GraphQL's.
at the moment there is only basic functionality,
but we can extend in the future:
- Accounts (accounts-base):`
- Extends Schema:
graphql``
type Mutation {
loginWithToken(token: String!): ID!
logout: ID
}
- AutoLogin when Meteor login, auto log out when Meteor logs out.
- AutoLogin GraphiQL as well.
#### Example Repository
TODO
#### Contribution
Contributions, issues and feature requests are very welcome. If you are using this package and fixed a bug for yourself, please consider submitting a PR!