Updated Schema

.babelrc

@@ -0,0 +1,20 @@
+{
+  "presets": [
+    [
+      "env",
+      {
+        "targets": {
+          "node": "8.2.1"
+        }
+      }
+    ]
+  ],
+  "plugins": [
+    [
+      "transform-object-rest-spread",
+      {
+        "useBuiltIns": true
+      }
+    ]
+  ]
+}

package.json

@@ -2,15 +2,25 @@
   "private": true,
   "main": "./src/server.js",
   "scripts": {
-    "start": "node ./src/server.js"
+    "start": "babel-node ./src/server.js",
+    "dev": "cross-env NODE_ENV=dev nodemon --exec babel-node ./src/server.js"
   },
   "dependencies": {
     "apollo-engine": "^1.0.1",
     "apollo-server-express": "1.3.2",
     "body-parser": "^1.17.1",
+    "cross-env": "^5.1.4",
     "express": "^4.15.2",
     "graphql": "0.13.0",
+    "graphql-date": "^1.0.3",
     "graphql-tools": "2.20.2",
+    "mongoose": "^5.0.12",
     "node-fetch": "^2.0.0"
+  },
+  "devDependencies": {
+    "babel-cli": "^6.26.0",
+    "babel-plugin-transform-object-rest-spread": "^6.26.0",
+    "babel-preset-env": "^1.6.1",
+    "nodemon": "^1.17.3"
   }
 }

src/config/constants.js

@@ -0,0 +1,7 @@
+export default {
+  PORT: process.env.PORT || 3000,
+  DB_URL: "mongodb://localhost/gqltoy",
+  GRAPHQL_PATH: "/graphql",
+  JWT_SECRET: "thisisasecret123",
+  SUBSCRIPTIONS_PATH: "/subscriptions"
+};

src/config/db.js

@@ -0,0 +1,21 @@
+/* eslint-disable no-console */
+
+import mongoose from "mongoose";
+
+import constants from "./constants";
+
+mongoose.Promise = global.Promise;
+
+mongoose.set("debug", true); // debug mode on
+
+try {
+  mongoose.connect(constants.DB_URL);
+} catch (err) {
+  mongoose.createConnection(constants.DB_URL);
+}
+
+mongoose.connection
+  .once("open", () => console.log("MongoDB Running"))
+  .on("error", e => {
+    throw e;
+  });

src/graphql/resolvers/index.js

@@ -0,0 +1,30 @@
+import GraphQLDate from "graphql-date";
+
+import { TweetResolvers } from "./tweet-resolvers";
+// import UserResolvers from './user-resolvers';
+// import User from '../../models/User';
+
+export const resolvers = {
+  Date: GraphQLDate,
+  //   Tweet: {
+  //     user: ({ user }) => User.findById(user),
+  //   },
+  Query: {
+    // getTweet: TweetResolvers.getTweet,
+    // getTweets: TweetResolvers.getTweets,
+    // getUserTweets: TweetResolvers.getUserTweets,
+    // me: UserResolvers.me
+  },
+  Mutation: {
+    addTweet: TweetResolvers.addTweet
+    // updateTweet: TweetResolvers.updateTweet,
+    // deleteTweet: TweetResolvers.deleteTweet,
+    // favoriteTweet: TweetResolvers.favoriteTweet,
+    // signup: UserResolvers.signup,
+    // login: UserResolvers.login
+  }
+  //   Subscription: {
+  //     tweetAdded: TweetResolvers.tweetAdded,
+  //     tweetFavorited: TweetResolvers.tweetFavorited
+  //   }
+};

src/graphql/resolvers/tweet-resolvers.js

@@ -0,0 +1,127 @@
+import Tweet from "../../models/Tweet";
+// import FavoriteTweet from '../../models/FavoriteTweet';
+// import { requireAuth } from '../../services/auth';
+// import { pubsub } from '../../config/pubsub';
+
+// const TWEET_ADDED = "tweetAdded";
+// export const TWEET_FAVORITED = "tweetFavorited";
+
+export const TweetResolvers = {
+  addTweet: async (_, args, context) => {
+    try {
+      const tweet = await Tweet.create({ ...args });
+
+      return tweet;
+    } catch (error) {
+      throw error;
+    }
+  }
+  //   getTweet: async (_, { _id }, { user }) => {
+  //     try {
+  //       await requireAuth(user);
+  //       return Tweet.findById(_id);
+  //     } catch (error) {
+  //       throw error;
+  //     }
+  //   },
+  //   getTweets: async (_, args, { user }) => {
+  //     try {
+  //       await requireAuth(user);
+  //       const p1 = Tweet.find({}).sort({ createdAt: -1 });
+  //       const p2 = FavoriteTweet.findOne({ userId: user._id });
+  //       const [tweets, favorites] = await Promise.all([p1, p2]);
+
+  //       const tweetsToSend = tweets.reduce((arr, tweet) => {
+  //         const tw = tweet.toJSON();
+
+  //         if (favorites.tweets.some(t => t.equals(tweet._id))) {
+  //           arr.push({
+  //             ...tw,
+  //             isFavorited: true,
+  //           });
+  //         } else {
+  //           arr.push({
+  //             ...tw,
+  //             isFavorited: false,
+  //           })
+  //         }
+
+  //         return arr;
+  //       }, []);
+
+  //       return tweetsToSend;
+  //     } catch (error) {
+  //       throw error;
+  //     }
+  //   },
+  //   getUserTweets: async (_, args, { user }) => {
+  //     try {
+  //       await requireAuth(user);
+  //       return Tweet.find({ user: user._id }).sort({ createdAt: -1 })
+  //     } catch (error) {
+  //       throw error;
+  //     }
+  //   },
+  //   createTweet: async (_, args, { user }) => {
+  //     try {
+  //       await requireAuth(user);
+  //       const tweet = await Tweet.create({ ...args, user: user._id });
+
+  //       pubsub.publish(TWEET_ADDED, { [TWEET_ADDED]: tweet });
+
+  //       return tweet;
+  //     } catch (error) {
+  //       throw error;
+  //     }
+  //   },
+  //   updateTweet: async (_, { _id, ...rest }, { user }) => {
+  //     try {
+  //       await requireAuth(user);
+  //       const tweet = await Tweet.findOne({ _id, user: user._id });
+
+  //       if (!tweet) {
+  //         throw new Error('Not found!');
+  //       }
+
+  //       Object.entries(rest).forEach(([key, value]) => {
+  //         tweet[key] = value;
+  //       });
+
+  //       return tweet.save();
+  //     } catch (error) {
+  //       throw error;
+  //     }
+  //   },
+  //   deleteTweet: async (_, { _id }, { user }) => {
+  //     try {
+  //       await requireAuth(user);
+  //       const tweet = await Tweet.findOne({ _id, user: user._id });
+
+  //       if (!tweet) {
+  //         throw new Error('Not found!');
+  //       }
+  //       await tweet.remove();
+  //       return {
+  //         message: 'Delete Success!'
+  //       }
+  //     } catch (error) {
+  //       throw error;
+  //     }
+  //   },
+  //   favoriteTweet: async (_, { _id }, { user }) => {
+  //     try {
+  //       await requireAuth(user);
+  //       const favorites = await FavoriteTweet.findOne({ userId: user._id });
+
+  //       return favorites.userFavoritedTweet(_id);
+  //     } catch (error) {
+  //       throw error;
+  //     }
+  //   },
+  //   tweetAdded: {
+  //     subscribe: () => pubsub.asyncIterator(TWEET_ADDED)
+  //   },
+  //   tweetFavorited: {
+  //     subscribe: () => pubsub.asyncIterator(TWEET_FAVORITED),
+  //   }
+};

src/graphql/schema.js

@@ -1,24 +1,79 @@
 const gql = String.raw;
 
-// Construct a schema, using GraphQL schema language
-const typeDefs = gql`
+export const typeDefs = gql`
+  scalar Date
+
+  type Status {
+    message: String!
+  }
+
+  type Auth {
+    token: String!
+  }
+
+  type User {
+    _id: ID!
+    username: String
+    email: String!
+    firstName: String
+    lastName: String
+    avatar: String
+    createdAt: Date!
+    updatedAt: Date!
+  }
+
+  type Me {
+    _id: ID!
+    username: String
+    email: String!
+    firstName: String
+    lastName: String
+    avatar: String
+    createdAt: Date!
+    updatedAt: Date!
+  }
+
+  type Tweet {
+    _id: ID!
+    text: String!
+    user: User!
+    favoriteCount: Int!
+    isFavorited: Boolean
+    createdAt: Date!
+    updatedAt: Date!
+  }
+
   type Query {
-    myFavoriteArtists: [Artist]
+    getTweet(_id: ID!): Tweet
+    getTweets: [Tweet]
+    getUserTweets: [Tweet]
+    me: Me
   }
 
-  type Artist @cacheControl(maxAge: 60) {
-    id: ID
-    name: String
-    image: String
-    twitterUrl: String
-    events: [Event]
+  type Mutation {
+    addTweet(text: String!): Tweet
+    createTweet(text: String!): Tweet
+    updateTweet(_id: ID!, text: String): Tweet
+    deleteTweet(_id: ID!): Status
+    favoriteTweet(_id: ID!): Tweet
+    signup(
+      email: String!
+      fullName: String!
+      password: String!
+      avatar: String
+      username: String
+    ): Auth
+    login(email: String!, password: String!): Auth
   }
 
-  type Event @cacheControl(maxAge: 60) {
-    name: String
-    image: String
-    startDateTime: String
+  type Subscription {
+    tweetAdded: Tweet
+    tweetFavorited: Tweet
   }
-`;
 
-module.exports = { typeDefs };
+  schema {
+    query: Query
+    mutation: Mutation
+    subscription: Subscription
+  }
+`;

src/graphql/schema2.js

@@ -0,0 +1,24 @@
+// const gql = String.raw;
+
+// // Construct a schema, using GraphQL schema language
+// const typeDefs = gql`
+//   type Query {
+//     myFavoriteArtists: [Artist]
+//   }
+
+//   type Artist @cacheControl(maxAge: 60) {
+//     id: ID
+//     name: String
+//     image: String
+//     twitterUrl: String
+//     events: [Event]
+//   }
+
+//   type Event @cacheControl(maxAge: 60) {
+//     name: String
+//     image: String
+//     startDateTime: String
+//   }
+// `;
+
+// module.exports = { typeDefs };

src/models/Tweet.js

@@ -0,0 +1,39 @@
+import mongoose, { Schema } from "mongoose";
+
+const TweetSchema = new Schema(
+  {
+    text: {
+      type: String,
+      minlength: [5, "Text need to be longer"],
+      maxlength: [144, "Text too long"]
+    },
+    user: {
+      type: Schema.Types.ObjectId,
+      ref: "User"
+    },
+    favoriteCount: {
+      type: Number,
+      default: 0
+    }
+  },
+  { timestamps: true }
+);
+
+TweetSchema.statics = {
+  incFavoriteCount(tweetId) {
+    return this.findByIdAndUpdate(
+      tweetId,
+      { $inc: { favoriteCount: 1 } },
+      { new: true }
+    );
+  },
+  decFavoriteCount(tweetId) {
+    return this.findByIdAndUpdate(
+      tweetId,
+      { $inc: { favoriteCount: -1 } },
+      { new: true }
+    );
+  }
+};
+
+export default mongoose.model("Tweet", TweetSchema);