GraphQL For Beginners: Part #2 Hello Real World

'use strict';

const mongoose = require('mongoose');
mongoose.Promise = require('bluebird');

const bcrypt = require('bcrypt-nodejs');

const hash_password = ( password ) => {
	let salt = bcrypt.genSaltSync(); // enter number of rounds, default: 10
	let hash = bcrypt.hashSync( password, salt );
	return hash;
};

const UserSchema = mongoose.Schema(
	{
		name: {
			type: String,
			required: true
		},
		email: {
			type: String,
			lowercase: true,
			required: true,
			unique: true,
		},
		password: {
			type: String
		},
		phone: {
			type: String
		},
		status: {
			type: Number,
			default: 1
		},
	},
	{
		timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' },
		collection: 'users',
	}
);


UserSchema.methods.comparePassword = function(password) {
	if ( ! this.password ) {
		return false;
	}
	return bcrypt.compareSync( password, this.password );
};


UserSchema.pre('save', function(next) {
	// check if password is present and is modified.
	if ( this.password && this.isModified('password') ) {
		this.password = hash_password(this.password);
	}
	// do stuff
	next();
});


module.exports = mongoose.model( 'User', UserSchema );

'use strict';

const User = require('../../services/models/User');

class UserController {

	constructor(model) {
		this.model = User;
	}

	// this will find all the records in database and return it
	index() {
		return this.model.find()
			.sort('created_at')
			.exec()
			.then( records => {
				return records;
			})
			.catch( error => {
				return error;
			});
	}

	// this will find a single record based on id and return it.
	single( options ) {
		return this.model.findOne({ _id: options.id })
			.exec()
			.then( record => {
				return record;
			})
			.catch( error => {
				return error;
			});
	}

	// this will insert a new record in database
	create(data) {
		const record = new this.model(data);
		return record.save()
			.then( (record) => {
				return record;
			})
			.catch( (error) => {
				return error;
			});
	}

	// this will update existing record in database
	update(data) {
		return this.model.findOne({ _id: data.id })
			.exec()
			.then( (record) => {
				Object.keys(data).map( field => {
					record[field] = data[field];
				});

				return record.save()
					.then( updated => {
						return updated;
					})
					.catch( (error) => {
						return error;
					});

			})
			.catch( (error) => {
				return error;
			});
	}

	// this will remove the record from database.
	delete( options ) {
		this.model.findById( options.id )
			.exec()
			.then( record => {
				record.remove();
				return { status: true };
			})
			.catch( error => {
				return error;
			});
	}

};

const user_controller = new UserController();
module.exports = user_controller;

'use strict';

const GraphQL = require('graphql');
const {
	GraphQLObjectType,
	GraphQLString,
	GraphQLID,
	GraphQLInt,
} = GraphQL;


const UserType = new GraphQL.GraphQLObjectType({
	name: 'User',
	description: 'User type for managing all the users in our application.',

	fields: () => ({
		id: {
			type: GraphQLID,
			description: 'ID of the user, Generated automatically by MongoDB',
		},
		name: {
			type: GraphQLString,
			description: 'Full name of the user',
		},
		email: {
			type: GraphQLString,
			description: 'Email address of the user, must be valid and unique',
		},

		phone: {
			type: GraphQLString,
			description: 'Phone number of the user',
		},

		status: {
			type: GraphQLInt,
			description: 'Status of the user, whether active or disabled',
		},
		created_at: {
			type: GraphQLString,
			description: 'Date and time when this users account was created',
		},
		updated_at: {
			type: GraphQLString,
			description: 'Date and time when this users account was last updated',
		}

	})

});


module.exports = UserType;

'use strict';

const GraphQL = require('graphql');
const {
	GraphQLList,
	GraphQLID,
	GraphQLNonNull,
} = GraphQL;

// import the user type we created
const UserType = require('../types/User');

// import the user resolver we created
const UserResolver = require('../resolvers/User');


module.exports = {

	index() {
		return {
			type: new GraphQLList(UserType),
			description: 'This will return all the users present in the database',
			resolve(parent, args, context, info) {
				return UserResolver.index({});
			}
		}
	},

	single() {
		return {
			type: UserType,
			description: 'This will return data of a single users based on the id provided',
			args: {
				id: {
					type: new GraphQLNonNull(GraphQLID),
					description: 'Please enter user id',
				}
			},
			resolve(parent, args, context, info) {
				return UserResolver.single({ id: args.id });
			}
		}
	},

};

'use strict';

const GraphQL = require('graphql');
const {
	GraphQLNonNull,
	GraphQLString,
	GraphQLInt,
	GraphQLID,
} = GraphQL;

// lets import our user type
const UserType = require('../types/User');

// lets import our user resolver
const UserResolver = require('../resolvers/User');


module.exports = {

	create() {
		return {
			type: UserType,
			description: 'Add new User',

			args: {
				name: {
					type: new GraphQLNonNull(GraphQLString),
					description: 'Enter users full name, Cannot be left empty',
				},
				email: {
					type: new GraphQLNonNull(GraphQLString),
					description: 'Enter users email address, Must be valid and unique',
				},
				password: {
					type: new GraphQLNonNull(GraphQLString),
					description: 'Enter users password, will be automatically hashed',
				},
				phone: {
					type: GraphQLString,
					description: 'Enter users phone number',
				},
				status: {
					type: GraphQLInt,
					description: 'Enters users status, by default its set to active. 1: active, 2: disabled',
				},
			},
			resolve(parent, fields) {
				return UserResolver.create(fields);
			}
		}
	},


	update() {
		return {
			type: UserType,
			description: 'Update user details',

			args: {
				id: {
					type: new GraphQLNonNull(GraphQLID),
					description: 'Enter user id',
				},
				name: {
					type: GraphQLString,
					description: 'Enter users full name, Cannot be left empty',
				},
				email: {
					type: GraphQLString,
					description: 'Enter users email address, Must be valid and unique',
				},
				password: {
					type: GraphQLString,
					description: 'Enter users password, will be automatically hashed',
				},
				phone: {
					type: GraphQLString,
					description: 'Enter users phone number',
				},
				status: {
					type: GraphQLInt,
					description: 'Enters users status. 1: active, 2: disabled',
				},
			},
			resolve(parent, fields) {
				return UserResolver.update(fields);
			}

		}
	},


	delete() {
		return {
			type: UserType,
			description: 'Delete existing USer',

			args: {
				id: {
					type: new GraphQLNonNull(GraphQLID),
					description: 'Enter user id',
				},
			},
			resolve(parent, fields) {
				return UserResolver.delete(fields);
			}
		}
	},


};

'use strict';

const GraphQL = require('graphql');
const {
	GraphQLObjectType,
	GraphQLSchema,
} = GraphQL;


// import the user query file we created
const UserQuery = require('./queries/User');

// import the user mutation file we created
const UserMutation = require('./mutations/User');


// lets define our root query
const RootQuery = new GraphQLObjectType({
	name: 'RootQueryType',
	description: 'This is the default root query provided by the backend',
	fields: {
		users: UserQuery.index(),
		user: UserQuery.single(),
	},
});


// lets define our root mutation
const RootMutation = new GraphQLObjectType({
	name: 'Mutation',
	description: 'Default mutation provided by the backend APIs',
	fields: {
		addUser: UserMutation.create(),
		updateUser: UserMutation.update(),
		deleteUser: UserMutation.delete(),
	},
});



// export the schema
module.exports = new GraphQLSchema({
	query: RootQuery,
	mutation: RootMutation,
});

'use strict';

module.exports = {

	server: {
		PORT: process.env.PORT || 1221,
	},

	database: {
		HOST: process.env.MONGODB || 'mongodb://admin:MySuperS3cretPassw0rd@ds163940.mlab.com:63940/graphql',
	},

};

'use strict';

const express = require('express');
const body_parser = require('body-parser');
const cors = require('cors');
const config = require('./app/global/config');
const mongoose = require('mongoose');

const expressGraphQL = require('express-graphql');

// let's import the schema file we just created
const GraphQLSchema = require('./app/graphql');

mongoose.Promise = require('bluebird');
mongoose.connect( config.database.HOST );

const app = express();

app.set( 'port', config.server.PORT );
app.disable('x-powered-by');

app.use( cors({ optionsSuccessStatus: 200 }) );
app.use( body_parser.json({ limit: '50mb' }) );
app.use( body_parser.urlencoded({ limit: '50mb', extended: true }) );


// here we specify where we want our GraphQL server to be accessible at, For now /graphql seems fine.
// graphiql is the GUI we can use play around with our GraphQL server, Lets enable this for now, Disable this in the production.
app.use(
	'/graphql',
	expressGraphQL( () => {
		return {
			graphiql: true,
			schema: GraphQLSchema,
		}
	})
);

// our default route.
app.get( '/', (req, res) => {
	res.json({
		code: 200,
		message: 'Hello World'
	});
});

// start the server
app.listen(
	app.get('port'),
	() => {
		const port = app.get('port');
		console.log('GraphQL Server Running at http://127.0.0.1:' + port );
	}
);

"scripts": {
    "start": "node server.js"
  },