Edit

Generating Schema

SchemaComposer allows to build a GraphQLSchema instance. The Schema obtained calling the buildSchema() method may be used in express-graphql, apollo-server and other libs that use GraphQL.js under the hood for query execution at runtime.

Create Schema

SchemaComposer provides three basic root types: Query, Mutation and Subscription. It's imperative to initialize at least one of those, otherwise our Schema would not build.

import { schemaComposer } from 'graphql-compose';
import { AuthorTC } from './author';

schemaComposer.Query.addFields({
  // add field with regular FieldConfig
  currentTime: {
    type: 'Date',
    resolve: () => Date.now(),
  },
  // Assume that `AuthorTC` build with `graphql-compose-mongoose` which has CRUD resolvers
  // in such case we can use pre-generated Resolvers as a FieldConfig
  authorById: AuthorTC.getResolver('findById'),
  authorMany: AuthorTC.getResolver('findMany'),
  // ...
});

schemaComposer.Mutation.addNestedFields({
  // also it may be very useful define nested fields
  // Mutation will have `author` field, `author` will have `create` and `update` fields inside
  'author.create': AuthorTC.getResolver('createOne'),
  'author.update': AuthorTC.getResolver('updateById'),
  // ...
});

export default schemaComposer.buildSchema(); // exports GraphQLSchema

Restrict access

GraphQL.js does not provide any access rights checks, so a developer would need to implemented them manually in the resolve methods. With graphql-compose it can be done by wrapping Resolvers:

// rootMutation.js
import { schemaComposer } from 'graphql-compose';

import { CommentTC } from './comment';
import { UserTC } from './user';

schemaComposer.Mutation.addNestedFields({
  commentCreate: CommentTC.getResolver('createOne'), // may anybody

  ...adminAccess({
    // only for admins
    'user.create': UserTC.getResolver('createOne'),
    'user.update': UserTC.getResolver('updateById'),
    'user.remove': UserTC.getResolver('removeById'),
  }),
});

function adminAccess(resolvers) {
  Object.keys(resolvers).forEach(k => {
    resolvers[k] = resolvers[k].wrapResolve(next => rp => {
      if (!rp.context.isAdmin) {
        throw new Error('You should be admin, to have access to this action.');
      }
      return next(rp);
    });
  });
  return resolvers;
}

The isAdmin property from the above example must be defined in express-graphql or apollo-server, in order to retrieve it from context:

import express from 'express';
import graphqlHTTP from 'express-graphql';
import { schema } from './schema';

const PORT = 4000;
const app = express();

app.use(
  '/graphql',
  graphqlHTTP(async (request, response, graphQLParams) => {
    return {
      schema,
      graphiql: true,
      context: {
        req: request,
        isAdmin: someMethodForCheckingCookiesOrHeaders(request),
      },
    };
  })
);

app.listen(PORT, () => {
  console.log(`The server is running at http://localhost:${PORT}/graphql`);
});

Multiple Schemas

In some complex scenarios we may need several GraphQL Schemas within a single app. graphql-compose by default exports the following classes/instances for single schema mode:

import { schemaComposer } from 'graphql-compose';

The equivalent class for multi-schema mode is called SchemaComposer (with a capital S). Unlike with single-schema where we have a static class, SchemaComposer has a constructor and allows creating multiple instances:

import { SchemaComposer } from 'graphql-compose';

const schemaComposer1 = new SchemaComposer();
const ObjectTypeComposer1 = schemaComposer1.createObjectTC(...);

const schemaComposer2 = new SchemaComposer();
const ObjectTypeComposer2 = schemaComposer2.createObjectTC(...);
const InputTypeComposer2 = schemaComposer2.createInputTC(..);
const EnumTypeComposer2 = schemaComposer2.createEnumTC(...);
const UnionTypeComposer2 = schemaComposer2.createUnionTC(...);
const InterfaceTypeComposer2 = schemaComposer2.createInterfaceTC(...);
const ScalarTypeComposer2 = schemaComposer2.createScalarTC(...);
const Resolver2 = schemaComposer2.createResolver(...);

Types created via ObjectTypeComposer1 and ObjectTypeComposer2 will not be visible to each other: name-clashing and overriding would not be isssues, and multiple definitions for types with the same name are allowed, as long as they live in separate SchemaComposer instances.