# Build a Complete App with GraphQL, Node.js, MongoDB and React.js

const express = require('express');
const bodyParser = require('body-parser');

const app = express();

app.use(bodyParser.json());

app.listen(3000);

const express = require('express');
const bodyParser = require('body-parser');

const app = express();

app.use(bodyParser.json());

app.get('/', (req,res,next) => {
  res.send('Hello World!');
})

app.listen(3000);

const express = require('express');
const bodyParser = require('body-parser');
const graphqlHttp = require('express-graphql');
const { buildSchema } = require('graphql');
const app = express();

app.use(bodyParser.json());

app.use('/graphql', graphqlHttp({
  schema: buildSchema(`
    type RootQuery {
      events: [String!]!
    }

    type RootMutation {
      createEvent(name: String): String
    }

    schema {
      query: RootQuery
      mutation: RootMutation
    }
  `),
  rootValue: {
    events: () => {
      return ['Romantic Cooking', 'Sailing', 'All-night coding']
    },
    createEvent: (args) => {
      const eventName = args.name;
      return eventName;
    },
    graphiql: true
  }
}));
app.listen(3000);

const express = require('express');
const bodyParser = require('body-parser');
const graphqlHttp = require('express-graphql');
const { buildSchema } = require('graphql');
const app = express();

app.use(bodyParser.json());

const events = [];

app.use('/graphql', graphqlHttp({
  schema: buildSchema(`
    type Event {
      _id: ID!
      title: String!
      description: String!
      price: Float!
      date: String!
    }

    input EventInput {
      title: String!
      description: String!
      price: Float!
      date: String!      
    }

    type RootQuery {
      events: [Event!]!
    }

    type RootMutation {
      createEvent(eventInput: EventInput): Event
    }

    schema {
      query: RootQuery
      mutation: RootMutation
    }
  `),
  rootValue: {
    events: () => {
      return events;
    },
    createEvent: (args) => {
      const event = {
        _id: Math.random().toString(),
        title: args.eventInput.title,
        description: args.eventInput.description,
        price: +args.eventInput.price,
        date: args.eventInput.date
      }
      events.push(event);
      return event;
    },
    graphiql: true
  }
}));
app.listen(3000);

const express = require('express');
const bodyParser = require('body-parser');
const graphqlHttp = require('express-graphql');
const { buildSchema } = require('graphql');
const mongoose = require('mongoose');

const app = express();

app.use(bodyParser.json());

const events = [];

app.use('/graphql', graphqlHttp({
  schema: buildSchema(`
    type Event {
      _id: ID!
      title: String!
      description: String!
      price: Float!
      date: String!
    }

    input EventInput {
      title: String!
      description: String!
      price: Float!
      date: String!      
    }

    type RootQuery {
      events: [Event!]!
    }

    type RootMutation {
      createEvent(eventInput: EventInput): Event
    }

    schema {
      query: RootQuery
      mutation: RootMutation
    }
  `),
  rootValue: {
    events: () => {
      return events;
    },
    createEvent: (args) => {
      const event = {
        _id: Math.random().toString(),
        title: args.eventInput.title,
        description: args.eventInput.description,
        price: +args.eventInput.price,
        date: args.eventInput.date
      }
      events.push(event);
      return event;
    },
    graphiql: true
  }
}));

mongoose
  .connect(`mongodb+srv://${process.env.MONGO_USER}:${process.env.MONGO_PASSWORD}@cluster0-ycwj8.mongodb.net/${process.env.MONGO_DB}?retryWrites=true`)
  .then(() => {
    app.listen(3000);
  })
  .catch(err => {
    console.log(err);
  })

const moongose = require('mongoose');

const Schema = moongose.Schema;

const eventSchema = new Schema({
  title: {
    type: String,
    required: true
  },
  description: {
    type: String,
    required: true
  },
  price: {
    type: Number,
    required: true
  },
  date: {
    type: Date,
    required: true
  },
});

module.exports = moongose.model('Event', eventSchema);

const express = require('express');
const bodyParser = require('body-parser');
const graphqlHttp = require('express-graphql');
const { buildSchema } = require('graphql');
const mongoose = require('mongoose');

const Event = require('./models/event');

const app = express();

app.use(bodyParser.json());

app.use('/graphql', graphqlHttp({
  schema: buildSchema(`
    type Event {
      _id: ID!
      title: String!
      description: String!
      price: Float!
      date: String!
    }

    input EventInput {
      title: String!
      description: String!
      price: Float!
      date: String!      
    }

    type RootQuery {
      events: [Event!]!
    }

    type RootMutation {
      createEvent(eventInput: EventInput): Event
    }

    schema {
      query: RootQuery
      mutation: RootMutation
    }
  `),
  rootValue: {
    events: () => {
      return events;
    },
    createEvent: (args) => {
      const event = new Event({
        title: args.eventInput.title,
        description: args.eventInput.description,
        price: +args.eventInput.price,
        date: new Date(args.eventInput.date)
      });
      return event
        .save()
        .then(result => {
          console.log(result);
          return { ...result._doc};
        })
        .catch(err => {
          console.log(err);
          throw err;
        })
    },
    graphiql: true
  }
}));



mongoose
  .connect(`mongodb+srv://${process.env.MONGO_USER}:${process.env.MONGO_PASSWORD}@cluster0-ycwj8.mongodb.net/${process.env.MONGO_DB}?retryWrites=true`)
  .then(() => {
    app.listen(3000);
  })
  .catch(err => {
    console.log(err);
  })

const express = require('express');
const bodyParser = require('body-parser');
const graphqlHttp = require('express-graphql');
const { buildSchema } = require('graphql');
const mongoose = require('mongoose');

const Event = require('./models/event');

const app = express();

app.use(bodyParser.json());

app.use('/graphql', graphqlHttp({
  schema: buildSchema(`
    type Event {
      _id: ID!
      title: String!
      description: String!
      price: Float!
      date: String!
    }

    input EventInput {
      title: String!
      description: String!
      price: Float!
      date: String!      
    }

    type RootQuery {
      events: [Event!]!
    }

    type RootMutation {
      createEvent(eventInput: EventInput): Event
    }

    schema {
      query: RootQuery
      mutation: RootMutation
    }
  `),
  rootValue: {
    events: () => {
      return Event
        .find()
        .then(events => {
          return events.map(event => {
            return {...event._doc};
          })
        })
        .catch(err => {
          console.log(err);
          throw err;
        })       
    },
    createEvent: (args) => {
      const event = new Event({
        title: args.eventInput.title,
        description: args.eventInput.description,
        price: +args.eventInput.price,
        date: new Date(args.eventInput.date)
      });
      return event
        .save()
        .then(result => {
          console.log(result);
          return { ...result._doc};
        })
        .catch(err => {
          console.log(err);
          throw err;
        })
    },
    graphiql: true
  }
}));

mongoose
  .connect(`mongodb+srv://${process.env.MONGO_USER}:${process.env.MONGO_PASSWORD}@cluster0-ycwj8.mongodb.net/${process.env.MONGO_DB}?retryWrites=true`)
  .then(() => {
    app.listen(3000);
  })
  .catch(err => {
    console.log(err);
  })

const express = require('express');
const bodyParser = require('body-parser');
const graphqlHttp = require('express-graphql');
const { buildSchema } = require('graphql');
const mongoose = require('mongoose');

const Event = require('./models/event');

const app = express();

app.use(bodyParser.json());

app.use('/graphql', graphqlHttp({
  schema: buildSchema(`
    type Event {
      _id: ID!
      title: String!
      description: String!
      price: Float!
      date: String!
    }

    input EventInput {
      title: String!
      description: String!
      price: Float!
      date: String!      
    }

    type RootQuery {
      events: [Event!]!
    }

    type RootMutation {
      createEvent(eventInput: EventInput): Event
    }

    schema {
      query: RootQuery
      mutation: RootMutation
    }
  `),
  rootValue: {
    events: () => {
      return Event
        .find()
        .then(events => {
          return events.map(event => {
            return {...event._doc, _id: event.id};
          })
        })
        .catch(err => {
          console.log(err);
          throw err;
        })       
    },
    createEvent: (args) => {
      const event = new Event({
        title: args.eventInput.title,
        description: args.eventInput.description,
        price: +args.eventInput.price,
        date: new Date(args.eventInput.date)
      });
      return event
        .save()
        .then(result => {
          console.log(result);
          return { ...result._doc, _id: result._doc._id.toString()};
        })
        .catch(err => {
          console.log(err);
          throw err;
        })
    },
    graphiql: true
  }
}));

mongoose
  .connect(`mongodb+srv://${process.env.MONGO_USER}:${process.env.MONGO_PASSWORD}@cluster0-ycwj8.mongodb.net/${process.env.MONGO_DB}?retryWrites=true`)
  .then(() => {
    app.listen(3000);
  })
  .catch(err => {
    console.log(err);
  })

const moongose = require('mongoose');

const Schema = moongose.Schema;

const userSchema = new Schema({
  email: {
    type: String,
    required: true
  },
  password: {
    type: String,
    required: true
  },
  createdEvents: [
    {
      type: Schema.Types.ObjectId,
      ref: 'Event'
    }
  ] 
});

module.exports = moongose.model('User', userSchema);

const moongose = require('mongoose');

const Schema = moongose.Schema;

const eventSchema = new Schema({
  title: {
    type: String,
    required: true
  },
  description: {
    type: String,
    required: true
  },
  price: {
    type: Number,
    required: true
  },
  date: {
    type: Date,
    required: true
  },
  creator: {
    type: Schema.Types.ObjectId,
    ref: 'User'
  }
});

module.exports = moongose.model('Event', eventSchema);

const express = require('express');
const bodyParser = require('body-parser');
const graphqlHttp = require('express-graphql');
const { buildSchema } = require('graphql');
const mongoose = require('mongoose');
const bcrypt = require('bcryptjs');

const Event = require('./models/event');
const User = require('./models/user');

const app = express();

app.use(bodyParser.json());

app.use('/graphql', graphqlHttp({
  schema: buildSchema(`
    type Event {
      _id: ID!
      title: String!
      description: String!
      price: Float!
      date: String!
    }

    type User {
      _id: ID!
      email: String!
      password: String
    }

    input EventInput {
      title: String!
      description: String!
      price: Float!
      date: String!      
    }

    input UserInput {
      email: String!
      password: String!
    }

    type RootQuery {
      events: [Event!]!
    }

    type RootMutation {
      createEvent(eventInput: EventInput): Event
      createUser(userInput: UserInput): User
    }

    schema {
      query: RootQuery
      mutation: RootMutation
    }
  `),
  rootValue: {
    events: () => {
      return Event
        .find()
        .then(events => {
          return events.map(event => {
            return {...event._doc, _id: event.id};
          })
        })
        .catch(err => {
          console.log(err);
          throw err;
        })       
    },
    createEvent: (args) => {
      const event = new Event({
        title: args.eventInput.title,
        description: args.eventInput.description,
        price: +args.eventInput.price,
        date: new Date(args.eventInput.date)
      });
      return event
        .save()
        .then(result => {
          console.log(result);
          return { ...result._doc, _id: result._doc._id.toString()};
        })
        .catch(err => {
          console.log(err);
          throw err;
        })
    },
    createUser: args => {
      return bcrypt
        .hash(args.userInput.password, 12)
        .then(hashPassword => {
          const user = new User({
            email: args.userInput.email,
            password: hashPassword
          });
          return user
            .save()
            .then(result => {
              console.log(result);
              return { ...result._doc, _id: result.id};
            })          
        })
        .catch(err => {
          console.log(err);
          throw err;
        })        
    },    
    graphiql: true
  }
}));

mongoose
  .connect(`mongodb+srv://${process.env.MONGO_USER}:${process.env.MONGO_PASSWORD}@cluster0-ycwj8.mongodb.net/${process.env.MONGO_DB}?retryWrites=true`)
  .then(() => {
    app.listen(3000);
  })
  .catch(err => {
    console.log(err);
  })

const express = require('express');
const bodyParser = require('body-parser');
const graphqlHttp = require('express-graphql');
const { buildSchema } = require('graphql');
const mongoose = require('mongoose');
const bcrypt = require('bcryptjs');

const Event = require('./models/event');
const User = require('./models/user');

const app = express();

app.use(bodyParser.json());

app.use('/graphql', graphqlHttp({
  schema: buildSchema(`
    type Event {
      _id: ID!
      title: String!
      description: String!
      price: Float!
      date: String!
    }

    type User {
      _id: ID!
      email: String!
      password: String
    }

    input EventInput {
      title: String!
      description: String!
      price: Float!
      date: String!      
    }

    input UserInput {
      email: String!
      password: String!
    }

    type RootQuery {
      events: [Event!]!
    }

    type RootMutation {
      createEvent(eventInput: EventInput): Event
      createUser(userInput: UserInput): User
    }

    schema {
      query: RootQuery
      mutation: RootMutation
    }
  `),
  rootValue: {
    events: () => {
      return Event
        .find()
        .then(events => {
          return events.map(event => {
            return {...event._doc, _id: event.id};
          })
        })
        .catch(err => {
          console.log(err);
          throw err;
        })       
    },
    createEvent: (args) => {
      const event = new Event({
        title: args.eventInput.title,
        description: args.eventInput.description,
        price: +args.eventInput.price,
        date: new Date(args.eventInput.date)
      });
      return event
        .save()
        .then(result => {
          console.log(result);
          return { ...result._doc, _id: result._doc._id.toString()};
        })
        .catch(err => {
          console.log(err);
          throw err;
        })
    },
    createUser: args => {
      return bcrypt
        .hash(args.userInput.password, 12)
        .then(hashPassword => {
          const user = new User({
            email: args.userInput.email,
            password: hashPassword
          });
          return user
            .save()
            .then(result => {
              console.log(result);
              return { ...result._doc, password: null, _id: result.id};
            })          
        })
        .catch(err => {
          console.log(err);
          throw err;
        })        
    },    
    graphiql: true
  }
}));

mongoose
  .connect(`mongodb+srv://${process.env.MONGO_USER}:${process.env.MONGO_PASSWORD}@cluster0-ycwj8.mongodb.net/${process.env.MONGO_DB}?retryWrites=true`)
  .then(() => {
    app.listen(3000);
  })
  .catch(err => {
    console.log(err);
  })


- `createUser` mutation request
```json
mutation {
  createUser(userInput: {
    	email: "test2@test.email", 
    	password: "tester"
  })
  {
    email
    password
  }
}

const express = require('express');
const bodyParser = require('body-parser');
const graphqlHttp = require('express-graphql');
const { buildSchema } = require('graphql');
const mongoose = require('mongoose');
const bcrypt = require('bcryptjs');

const Event = require('./models/event');
const User = require('./models/user');

const app = express();

app.use(bodyParser.json());

app.use('/graphql', graphqlHttp({
  schema: buildSchema(`
    type Event {
      _id: ID!
      title: String!
      description: String!
      price: Float!
      date: String!
    }

    type User {
      _id: ID!
      email: String!
      password: String
    }

    input EventInput {
      title: String!
      description: String!
      price: Float!
      date: String!      
    }

    input UserInput {
      email: String!
      password: String!
    }

    type RootQuery {
      events: [Event!]!
    }

    type RootMutation {
      createEvent(eventInput: EventInput): Event
      createUser(userInput: UserInput): User
    }

    schema {
      query: RootQuery
      mutation: RootMutation
    }
  `),
  rootValue: {
    events: () => {
      return Event
        .find()
        .then(events => {
          return events.map(event => {
            return {...event._doc, _id: event.id};
          })
        })
        .catch(err => {
          console.log(err);
          throw err;
        })       
    },
    createEvent: (args) => {
      const event = new Event({
        title: args.eventInput.title,
        description: args.eventInput.description,
        price: +args.eventInput.price,
        date: new Date(args.eventInput.date)
      });
      return event
        .save()
        .then(result => {
          console.log(result);
          return { ...result._doc, _id: result._doc._id.toString()};
        })
        .catch(err => {
          console.log(err);
          throw err;
        })
    },
    createUser: args => {
      return User
        .findOne({email: args.userInput.email})
        .then(user => {
          if (user) {
            throw new Error('User already exists.')
          }
          return bcrypt.hash(args.userInput.password, 12);
        })
        .then(hashPassword => {
          const user = new User({
            email: args.userInput.email,
            password: hashPassword
          });
          return user
            .save()
            .then(result => {
              console.log(result);
              return { ...result._doc, password: null, _id: result.id};
            })          
        })
        .catch(err => {
          console.log(err);
          throw err;
        })        
    },    
    graphiql: true
  }
}));

mongoose
  .connect(`mongodb+srv://${process.env.MONGO_USER}:${process.env.MONGO_PASSWORD}@cluster0-ycwj8.mongodb.net/${process.env.MONGO_DB}?retryWrites=true`)
  .then(() => {
    app.listen(3000);
  })
  .catch(err => {
    console.log(err);
  })

.
.
.
    createEvent: (args) => {
      const event = new Event({
        title: args.eventInput.title,
        description: args.eventInput.description,
        price: +args.eventInput.price,
        date: new Date(args.eventInput.date),
        creator: "5c3cc489a1f3273f984495ad"
      });
      let createdEvent;
      return event
        .save()
        .then(result => {
          console.log(result);
          createdEvent = { ...result._doc, _id: result._doc._id.toString()};
          return User.findById(result._doc.creator.toString())
        })
        .then(user => {
          if (!user) {
            throw new Error('User does not exists.')
          }
          user.createdEvents.push(event);
          return user.save();
        })
        .then(result => {
          console.log(result);
          return createdEvent;
        })        
        .catch(err => {
          console.log(err);
          throw err;
        })
    },
.

const express = require('express');
const bodyParser = require('body-parser');
const graphqlHttp = require('express-graphql');
const { buildSchema } = require('graphql');
const mongoose = require('mongoose');
const bcrypt = require('bcryptjs');

const Event = require('./models/event');
const User = require('./models/user');

const app = express();

app.use(bodyParser.json());

app.use('/graphql', graphqlHttp({
  schema: buildSchema(`
    type Event {
      _id: ID!
      title: String!
      description: String!
      price: Float!
      date: String!
      creator: User!
    }

    type User {
      _id: ID!
      email: String!
      password: String
      createdEvents: [Event!]
    }

    input EventInput {
      title: String!
      description: String!
      price: Float!
      date: String!      
    }

    input UserInput {
      email: String!
      password: String!
    }

    type RootQuery {
      events: [Event!]!
    }

    type RootMutation {
      createEvent(eventInput: EventInput): Event
      createUser(userInput: UserInput): User
    }

    schema {
      query: RootQuery
      mutation: RootMutation
    }
  `),
  rootValue: {
    events: () => {
      return Event
        .find()
        .populate('creator')
        .then(events => {
          return events.map(event => {
            return {
              ...event._doc, 
              _id: event.id,
              creator: {
                ...event._doc.creator._doc,
                _id: event._doc.creator.id
              }
            };
          })
        })
        .catch(err => {
          console.log(err);
          throw err;
        })       
    },
    createEvent: (args) => {
      const event = new Event({
        title: args.eventInput.title,
        description: args.eventInput.description,
        price: +args.eventInput.price,
        date: new Date(args.eventInput.date),
        creator: "5c3cc489a1f3273f984495ad"
      });
      let createdEvent;
      return event
        .save()
        .then(result => {
          console.log(result);
          createdEvent = { ...result._doc, _id: result._doc._id.toString()};
          return User.findById(result._doc.creator.toString())
        })
        .then(user => {
          if (!user) {
            throw new Error('User does not exists.')
          }
          user.createdEvents.push(event);
          return user.save();
        })
        .then(result => {
          console.log(result);
          return createdEvent;
        })        
        .catch(err => {
          console.log(err);
          throw err;
        })
    },
    createUser: args => {
      return User
        .findOne({email: args.userInput.email})
        .then(user => {
          if (user) {
            throw new Error('User already exists.')
          }
          return bcrypt.hash(args.userInput.password, 12);
        })
        .then(hashPassword => {
          const user = new User({
            email: args.userInput.email,
            password: hashPassword
          });
          return user
            .save()
            .then(result => {
              console.log(result);
              return { ...result._doc, password: null, _id: result.id};
            })          
        })
        .catch(err => {
          console.log(err);
          throw err;
        })        
    },    
    graphiql: true
  }
}));

mongoose
  .connect(`mongodb+srv://${process.env.MONGO_USER}:${process.env.MONGO_PASSWORD}@cluster0-ycwj8.mongodb.net/${process.env.MONGO_DB}?retryWrites=true`)
  .then(() => {
    app.listen(3000);
  })
  .catch(err => {
    console.log(err);
  })

const express = require('express');
const bodyParser = require('body-parser');
const graphqlHttp = require('express-graphql');
const { buildSchema } = require('graphql');
const mongoose = require('mongoose');
const bcrypt = require('bcryptjs');

const Event = require('./models/event');
const User = require('./models/user');

const app = express();

app.use(bodyParser.json());

const user = userId => {
  return User.findById(userId)
    .then(user => {
      return {...user._doc, _id: user.id};
    })
    .catch(err => {
      console.log(err);
      throw err;
    })
};

app.use('/graphql', graphqlHttp({
  schema: buildSchema(`
    type Event {
      _id: ID!
      title: String!
      description: String!
      price: Float!
      date: String!
      creator: User!
    }

    type User {
      _id: ID!
      email: String!
      password: String
      createdEvents: [Event!]
    }

    input EventInput {
      title: String!
      description: String!
      price: Float!
      date: String!      
    }

    input UserInput {
      email: String!
      password: String!
    }

    type RootQuery {
      events: [Event!]!
    }

    type RootMutation {
      createEvent(eventInput: EventInput): Event
      createUser(userInput: UserInput): User
    }

    schema {
      query: RootQuery
      mutation: RootMutation
    }
  `),
  rootValue: {
    events: () => {
      return Event
        .find()
        .then(events => {
          return events.map(event => {
            return {
              ...event._doc, 
              _id: event.id,
              creator: user.bind(this, event._doc.creator)
            };
          })
        })
        .catch(err => {
          console.log(err);
          throw err;
        })       
    },
    createEvent: (args) => {
      const event = new Event({
        title: args.eventInput.title,
        description: args.eventInput.description,
        price: +args.eventInput.price,
        date: new Date(args.eventInput.date),
        creator: "5c3cc489a1f3273f984495ad"
      });
      let createdEvent;
      return event
        .save()
        .then(result => {
          console.log(result);
          createdEvent = { ...result._doc, _id: result._doc._id.toString()};
          return User.findById(result._doc.creator.toString())
        })
        .then(user => {
          if (!user) {
            throw new Error('User does not exists.')
          }
          user.createdEvents.push(event);
          return user.save();
        })
        .then(result => {
          console.log(result);
          return createdEvent;
        })        
        .catch(err => {
          console.log(err);
          throw err;
        })
    },
    createUser: args => {
      return User
        .findOne({email: args.userInput.email})
        .then(user => {
          if (user) {
            throw new Error('User already exists.')
          }
          return bcrypt.hash(args.userInput.password, 12);
        })
        .then(hashPassword => {
          const user = new User({
            email: args.userInput.email,
            password: hashPassword
          });
          return user
            .save()
            .then(result => {
              console.log(result);
              return { ...result._doc, password: null, _id: result.id};
            })          
        })
        .catch(err => {
          console.log(err);
          throw err;
        })        
    },    
    graphiql: true
  }
}));

mongoose
  .connect(`mongodb+srv://${process.env.MONGO_USER}:${process.env.MONGO_PASSWORD}@cluster0-ycwj8.mongodb.net/${process.env.MONGO_DB}?retryWrites=true`)
  .then(() => {
    app.listen(3000);
  })
  .catch(err => {
    console.log(err);
  })

const express = require('express');
const bodyParser = require('body-parser');
const graphqlHttp = require('express-graphql');
const { buildSchema } = require('graphql');
const mongoose = require('mongoose');
const bcrypt = require('bcryptjs');

const Event = require('./models/event');
const User = require('./models/user');

const app = express();

app.use(bodyParser.json());

const events = eventIds => {
  return Event.find({_id: {$in: eventIds}})

    .then(events => {
      return events.map(event => {
        return {
          ...event._doc, 
          _id: event.id, 
          creator: user.bind(this, event._doc.creator)};
      }); 
    })
    .catch(err => {
      console.log(err);
      throw err;
    });  
}

const user = userId => {
  return User.findById(userId)
    .then(user => {
      return {...user._doc, _id: user.id, createdEvents: events.bind(this, user._doc.createdEvents)};
    })
    .catch(err => {
      console.log(err);
      throw err;
    })
};

app.use('/graphql', graphqlHttp({
  schema: buildSchema(`
    type Event {
      _id: ID!
      title: String!
      description: String!
      price: Float!
      date: String!
      creator: User!
    }

    type User {
      _id: ID!
      email: String!
      password: String
      createdEvents: [Event!]
    }

    input EventInput {
      title: String!
      description: String!
      price: Float!
      date: String!      
    }

    input UserInput {
      email: String!
      password: String!
    }

    type RootQuery {
      events: [Event!]!
    }

    type RootMutation {
      createEvent(eventInput: EventInput): Event
      createUser(userInput: UserInput): User
    }

    schema {
      query: RootQuery
      mutation: RootMutation
    }
  `),
  rootValue: {
    events: () => {
      return Event
        .find()
        .then(events => {
          return events.map(event => {
            return {
              ...event._doc, 
              _id: event.id,
              creator: user.bind(this, event._doc.creator)
            };
          })
        })
        .catch(err => {
          console.log(err);
          throw err;
        })       
    },
    createEvent: (args) => {
      const event = new Event({
        title: args.eventInput.title,
        description: args.eventInput.description,
        price: +args.eventInput.price,
        date: new Date(args.eventInput.date),
        creator: "5c3cc489a1f3273f984495ad"
      });
      let createdEvent;
      return event
        .save()
        .then(result => {
          console.log(result);
          createdEvent = { 
            ...result._doc, 
            _id: result._doc._id.toString(),
            creator: user.bind(this, result._doc.creator)
          };
          return User.findById(result._doc.creator.toString())
        })
        .then(user => {
          if (!user) {
            throw new Error('User does not exists.')
          }
          user.createdEvents.push(event);
          return user.save();
        })
        .then(result => {
          console.log(result);
          return createdEvent;
        })        
        .catch(err => {
          console.log(err);
          throw err;
        })
    },
    createUser: args => {
      return User
        .findOne({email: args.userInput.email})
        .then(user => {
          if (user) {
            throw new Error('User already exists.')
          }
          return bcrypt.hash(args.userInput.password, 12);
        })
        .then(hashPassword => {
          const user = new User({
            email: args.userInput.email,
            password: hashPassword
          });
          return user
            .save()
            .then(result => {
              console.log(result);
              return { ...result._doc, password: null, _id: result.id};
            })          
        })
        .catch(err => {
          console.log(err);
          throw err;
        })        
    },    
    graphiql: true
  }
}));

mongoose
  .connect(`mongodb+srv://${process.env.MONGO_USER}:${process.env.MONGO_PASSWORD}@cluster0-ycwj8.mongodb.net/${process.env.MONGO_DB}?retryWrites=true`)
  .then(() => {
    app.listen(3000);
  })
  .catch(err => {
    console.log(err);
  })

const { buildSchema } = require('graphql');

module.exports = buildSchema(`
  type Event {
    _id: ID!
    title: String!
    description: String!
    price: Float!
    date: String!
    creator: User!
  }

  type User {
    _id: ID!
    email: String!
    password: String
    createdEvents: [Event!]
  }

  input EventInput {
    title: String!
    description: String!
    price: Float!
    date: String!      
  }

  input UserInput {
    email: String!
    password: String!
  }

  type RootQuery {
    events: [Event!]!
  }

  type RootMutation {
    createEvent(eventInput: EventInput): Event
    createUser(userInput: UserInput): User
  }

  schema {
    query: RootQuery
    mutation: RootMutation
  }
`);

const bcrypt = require('bcryptjs');

const Event = require('../../models/event');
const User = require('../../models/user');

const events = eventIds => {
  return Event.find({_id: {$in: eventIds}})
    .then(events => {
      return events.map(event => {
        return {
        ...event._doc, 
        _id: event.id, 
        creator: user.bind(this, event._doc.creator)};
      }); 
    })
    .catch(err => {
      console.log(err);
      throw err;
    });  
  }
  
const user = userId => {
  return User.findById(userId)
    .then(user => {
      return {...user._doc, _id: user.id, createdEvents: events.bind(this, user._doc.createdEvents)};
    })
    .catch(err => {
      console.log(err);
      throw err;
    })
  };
  
module.exports = {
  events: () => {
    return Event
      .find()
      .then(events => {
        return events.map(event => {
          return {
            ...event._doc, 
            _id: event.id,
            creator: user.bind(this, event._doc.creator)
          };
        })
      })
      .catch(err => {
        console.log(err);
        throw err;
      })       
  },
  createEvent: (args) => {
    const event = new Event({
      title: args.eventInput.title,
      description: args.eventInput.description,
      price: +args.eventInput.price,
      date: new Date(args.eventInput.date),
      creator: "5c3cc489a1f3273f984495ad"
    });
    let createdEvent;
    return event
      .save()
      .then(result => {
        console.log(result);
        createdEvent = { 
          ...result._doc, 
          _id: result._doc._id.toString(),
          creator: user.bind(this, result._doc.creator)
        };
        return User.findById(result._doc.creator.toString())
      })
      .then(user => {
        if (!user) {
          throw new Error('User does not exists.')
        }
        user.createdEvents.push(event);
        return user.save();
      })
      .then(result => {
        console.log(result);
        return createdEvent;
      })        
      .catch(err => {
        console.log(err);
        throw err;
      })
  },
  createUser: args => {
    return User
      .findOne({email: args.userInput.email})
      .then(user => {
        if (user) {
          throw new Error('User already exists.')
        }
        return bcrypt.hash(args.userInput.password, 12);
      })
      .then(hashPassword => {
        const user = new User({
          email: args.userInput.email,
          password: hashPassword
        });
        return user
          .save()
          .then(result => {
            console.log(result);
            return { ...result._doc, password: null, _id: result.id};
          })          
      })
      .catch(err => {
        console.log(err);
        throw err;
      })        
  }
}

const express = require('express');
const bodyParser = require('body-parser');
const graphqlHttp = require('express-graphql');
const mongoose = require('mongoose');

const graphQlSchema = require('./graphql/schema/index')
const graphQlResolvers = require('./graphql/resolvers/index')

const app = express();

app.use(bodyParser.json());

app.use('/graphql', graphqlHttp({
  schema: graphQlSchema,
  rootValue: graphQlResolvers,    
  graphiql: true
}));

mongoose
  .connect(`mongodb+srv://${process.env.MONGO_USER}:${process.env.MONGO_PASSWORD}@cluster0-ycwj8.mongodb.net/${process.env.MONGO_DB}?retryWrites=true`)
  .then(() => {
    app.listen(3000);
  })
  .catch(err => {
    console.log(err);
  })

const bcrypt = require('bcryptjs');

const Event = require('../../models/event');
const User = require('../../models/user');

const events = eventIds => {
  return Event.find({_id: {$in: eventIds}})
    .then(events => {
      return events.map(event => {
        return {
        ...event._doc, 
        _id: event.id, 
        date: new Date(event._doc.date).toISOString(),
        creator: user.bind(this, event._doc.creator)};
      }); 
    })
    .catch(err => {
      console.log(err);
      throw err;
    });  
  }
  
const user = userId => {
  return User.findById(userId)
    .then(user => {
      return {
        ...user._doc, 
        _id: user.id, 
        createdEvents: events.bind(this, user._doc.createdEvents)
      };
    })
    .catch(err => {
      console.log(err);
      throw err;
    })
  };
  
module.exports = {
  events: () => {
    return Event
      .find()
      .then(events => {
        return events.map(event => {
          return {
            ...event._doc, 
            _id: event.id,
            date: new Date(event._doc.date).toISOString(),
            creator: user.bind(this, event._doc.creator)
          };
        })
      })
      .catch(err => {
        console.log(err);
        throw err;
      })       
  },
  createEvent: (args) => {
    const event = new Event({
      title: args.eventInput.title,
      description: args.eventInput.description,
      price: +args.eventInput.price,
      date: new Date(args.eventInput.date),
      creator: "5c3cc489a1f3273f984495ad"
    });
    let createdEvent;
    return event
      .save()
      .then(result => {
        console.log(result);
        createdEvent = { 
          ...result._doc, 
          _id: result._doc._id.toString(),
          date: new Date(event._doc.date).toISOString(),
          creator: user.bind(this, result._doc.creator)
        };
        return User.findById(result._doc.creator.toString())
      })
      .then(user => {
        if (!user) {
          throw new Error('User does not exists.')
        }
        user.createdEvents.push(event);
        return user.save();
      })
      .then(result => {
        console.log(result);
        return createdEvent;
      })        
      .catch(err => {
        console.log(err);
        throw err;
      })
  },
  createUser: args => {
    return User
      .findOne({email: args.userInput.email})
      .then(user => {
        if (user) {
          throw new Error('User already exists.')
        }
        return bcrypt.hash(args.userInput.password, 12);
      })
      .then(hashPassword => {
        const user = new User({
          email: args.userInput.email,
          password: hashPassword
        });
        return user
          .save()
          .then(result => {
            console.log(result);
            return { ...result._doc, password: null, _id: result.id};
          })          
      })
      .catch(err => {
        console.log(err);
        throw err;
      })        
  }
}

const bcrypt = require('bcryptjs');

const Event = require('../../models/event');
const User = require('../../models/user');

const events = async eventIds => {
  try {
    const events = await Event.find({ _id: { $in: eventIds } });
    return events.map(event => {
      return {
        ...event._doc,
        _id: event.id,
        date: new Date(event._doc.date).toISOString(),
        creator: user.bind(this, event._doc.creator)
      };
    });
  }
  catch (err) {
    console.log(err);
    throw err;
  }  
}

const user = async userId => {
  try {
    const user = await User.findById(userId);
    return {
      ...user._doc,
      _id: user.id,
      createdEvents: events.bind(this, user._doc.createdEvents)
    };
  }
  catch (err) {
    console.log(err);
    throw err;
  }
};
  
module.exports = {
  events: async () => {
    try {
      const events = await Event.find();
      return events.map(event => {
        return {
          ...event._doc,
          _id: event.id,
          date: new Date(event._doc.date).toISOString(),
          creator: user.bind(this, event._doc.creator)
        };
      });
    }
    catch (err) {
      console.log(err);
      throw err;
    }       
  },
  createEvent: async args => {
    try {
      const event = new Event({
        title: args.eventInput.title,
        description: args.eventInput.description,
        price: +args.eventInput.price,
        date: new Date(args.eventInput.date),
        creator: "5c3cc489a1f3273f984495ad"
      });
      const result = await event.save();
      const creator = await User.findById(result._doc.creator.toString())
      if (!creator) {
        throw new Error('User does not exists.')
      }
      creator.createdEvents.push(event);
      await creator.save();
      return { 
        ...result._doc, 
        _id: result._doc._id.toString(),
        date: new Date(event._doc.date).toISOString(),
        creator: user.bind(this, result._doc.creator)
      };
    }
    catch (err) {
      console.log(err);
      throw err;
    }      
 },
  createUser: async args => {
    try {
      const user = await User.findOne({ email: args.userInput.email });
      if (user) {
        throw new Error('User already exists.');
      }
      const hashPassword = await bcrypt.hash(args.userInput.password, 12);
      const newUser = new User({
        email: args.userInput.email,
        password: hashPassword
      });
      const result = await newUser.save();
      return {
        ...result._doc,
        password: null,
        _id: result.id
      }
    }
    catch (err) {
      console.log(err);
      throw err;
    }        
  }
}