graphql-server

graphql-server.js

import {
  GraphQLSchema,
  GraphQLObjectType,
  GraphQLList,
  GraphQLString,
  GraphQLID,
  GraphQLBoolean,
  GraphQLNonNull,
  GraphQLInt
} from 'graphql';

const users = [
  {
    id: 0, name: 'ical', active: false
  },
  {
    id: 1, name: 'noom', active: false
  },
  {
    id: 2, name: 'marissa', active: false
  },
  {
    id: 3, name: 'john', active: true
  },
  {
    id: 4, name: 'algebra', active: false
  }
];
const followers = [
  {
    id: 103,
    name: 'anonymous'
  }
];

const likers = [
  {
    total: 123
  }
]

const LikerType = new GraphQLObjectType({
  name: 'LikerType',
  fields: () => ({
    total: {
      type: GraphQLInt
    }
  })
})
const FollowerType = new GraphQLObjectType({
  name: 'FollowerType',
  fields: () => ({
    id: {
      type: GraphQLID
    },
    name: {
      type: GraphQLString
    },
    likers: {
      type: new GraphQLList(LikerType),
      resolve: () => {
        return new Promise((resolve, reject) => {
          resolve(likers)
        })
      }
    }
  })
});

const UserType = new GraphQLObjectType({
  name: 'UserTypeQL',
  description: 'A users type',
  fields: () => ({
    id: {
      type: GraphQLID,
      description: 'ID'
    },
    name: {
      type: GraphQLString,
      description: 'A field name'
    },
    active: {
      type: GraphQLBoolean,
      description: 'A field of active'
    },
    followers: {
      type: new GraphQLList(FollowerType),
      resolve: () => {
        return new Promise((resolve, reject) => {
          resolve(followers)
        })
      }
    }
  })
});

const UsersQuery = new GraphQLObjectType({
  name: 'UsersQuery',
  description: 'A users query',
  fields: () => ({
    users: {
      type: new GraphQLList(UserType),
      description: 'A list of users',
      resolve: () => {
        return users
      }
    }
  })
});

const UsersMutation = new GraphQLObjectType({
  name: 'UsersMutation',
  description: 'A users mutation',
  fields: () => ({
    addUser: {
      type: UserType,
      args: {
        id: {
          type: new GraphQLNonNull(GraphQLID)
        },
        name: {
          type: new GraphQLNonNull(GraphQLString)
        }
      },
      resolve: (root, {id, name}) => {
        let merge = {
          id: id,
          name: name,
          active: true
        }
        let result = Object.assign(users, merge);
        return new Promise((resolve, reject) => {
          resolve(result)
        })
      }
    }
  })
})

const schema = new GraphQLSchema({
  query: UsersQuery,
  mutation: UsersMutation
});

export default schema;