microservice-chassis-apollo

An MC plugin for apollo graphql support.

This plugin in turn loads its own plugins to allow you to produce a modularized graphql schema.

An example of a graphql schema module can be found here

Getting Started

microservice-chassis-apollo is intended for use, unsurprisingly enough, with microservice-chassis:

npm i --save @earnest-labs/microservice-chassis @earnest-labs/microservice-chassis-apollo

At this point, you should be able to see the Apollo GraphQL Explorer, which will include a ping Query

% npx chassis-start &

% open http://localhost:3000/graphql

% curl 'http://localhost:3000/graphql' -X POST \
  -H 'Content-Type: application/json; charset=utf-8' \
  -H 'Origin: http://localhost:3000' \
  --data-raw '{"query":"query Query {ping {name version}}","variables":{},"operationName":"Query"}'
{"data":{"ping":{"name":"your-project-name","version":"0.0.1"}}}

To create a GQL schema module, define a typescript module, with a name matching *.apollo.ts, that has a default export conforming to the ApolloChassisPluginBuilder type. This type is an async function that takes a PluginContex (defined in @earnest-labs/microservice-chassis) and returns an ApolloChassisPlugin

You may have as many GQL schema modules as you like, though if they contain conflicting information, like re-using type names, your service will likely fail to start. Coordinating type, query, and mutation names is up to you.

Details On ApolloChassisPlugin

The current definition is in src/apollo.chassis-plugin.ts, and looks something like this:

export interface ApolloChassisPlugin {
    name: string;
    version: string;

    types?: string[];
    queries?: string[];
    mutations?: string[];
    resolver?: {
        Query?: Object,
        Mutation?: Object
    }
}

As you can see, most of the entries are optional.

types is a collection of graphql strings representing the types in your schema, e.g.:

result.types = [
  `type SomeModel {name: String, version: String, field: Int}`,
  `type AnotherModel {id: Int, name: String, value: String}`
]

queries is a collection of graphql strings representing entries in the Query object. An example entry might look like this:

result.queries = [
  'model: SomeModel',
  'anotherModel: AnotherModel'
]

mutations is a collection of graphql strings representing entries in the Mutation object. An example entry might look like this:

result.mutations = [
  'updateModel(name: String, field: Int) : Model',
  'updateAnotherModel(id: Int, value: String): AnotherModel'
]

resolver is an Apollo resolver object, with a Query subobject to deal with entries in queries, and a Mutation subobject to deal with entries in mutations. For example:

result.resolver = {
  Query: {
    model: async() => ({name: "hardcoded-name", version: "hardcoded-version", field: 42}),
    anotherModel: async() => ({id: 42, name: "hardcoded-name", value: "hardcoded-value"}),
  },
  Mutation: {
    updateModel: async(_, {name, field}) => ({name, version: "hardcoded-version", field}),
    updateAnotherModel: async(_, {id, value}) => ({id, name: "hardcoded-name", value}),
  }
}