part 7

Author: dhatGuy

part7/extended-blog/app.js

@@ -0,0 +1,39 @@
+const express = require("express");
+require("express-async-errors");
+const app = express();
+const cors = require("cors");
+const mongoose = require("mongoose");
+const config = require("./utils/config");
+const blogRouter = require("./controllers/blog");
+const userRouter = require("./controllers/users");
+const morgan = require("morgan");
+const middleware = require("./utils/middleware");
+const loginRouter = require("./controllers/login");
+
+morgan.token("body", function (req, res) {
+  return JSON.stringify(req.body);
+});
+
+mongoose.connect(config.mongoUrl, {
+  useNewUrlParser: true,
+  useUnifiedTopology: true,
+  useFindAndModify: false,
+  useCreateIndex: true,
+});
+
+app.use(cors());
+app.use(express.json());
+app.use(
+  morgan(":method :url :status :res[content-length] - :response-time ms :body")
+);
+app.use("/api/blogs", blogRouter);
+app.use("/api/users", userRouter);
+app.use("/api/login", loginRouter);
+if (process.env.NODE_ENV === "test") {
+  const testingRouter = require("./controllers/testing");
+  app.use("/api/testing", testingRouter);
+}
+app.use(middleware.unknownEndpoint);
+app.use(middleware.errorHandler);
+
+module.exports = app;

part7/extended-blog/controllers/blog.js

@@ -0,0 +1,86 @@
+require("dotenv").config();
+const blogRouter = require("express").Router();
+const Blog = require("../models/blog");
+const User = require("../models/user");
+const Comment = require("../models/comment");
+const jwt = require("jsonwebtoken");
+const { tokenExtractor } = require("../utils/middleware");
+
+blogRouter
+  .route("/")
+  .get(async (req, res) => {
+    const blogs = await Blog.find({}).populate("user").populate("comments");
+    res.json(blogs);
+  })
+  .post(tokenExtractor, async (req, res) => {
+    const { author, title, url, likes } = req.body;
+
+    const user = await User.findById(req.user);
+
+    if (!title || !url) res.status(400).end();
+
+    const blog = new Blog({
+      author: author || "unknown",
+      title,
+      url,
+      likes: likes || 0,
+      user: user._id,
+    });
+
+    const savedBlog = await blog.save();
+    user.blogs = [...user.blogs, savedBlog._id];
+    await user.save();
+    res.status(201).json(savedBlog);
+  });
+
+blogRouter
+  .route("/:id")
+  .get(async (req, res) => {
+    const blog = await Blog.findById(req.params.id);
+    if (blog) {
+      res.json(blog.toJSON());
+    } else {
+      res.status(404).end();
+    }
+  })
+  .delete(tokenExtractor, async (req, res) => {
+    const { user } = req;
+    const blog = await Blog.findById(req.params.id);
+
+    if (blog === null) return res.status(400).end();
+
+    if (blog.user.toString() === user) {
+      await Blog.findByIdAndRemove(req.params.id);
+      res.status(204).end();
+    } else {
+      res.status(400).end();
+    }
+  })
+  .put(async (req, res) => {
+    const { comments, ...blog } = req.body;
+    const updatedBlog = await Blog.findByIdAndUpdate(req.params.id, blog, {
+      new: true,
+    });
+    res.json(updatedBlog);
+  });
+
+blogRouter.route("/:id/comments").post(async (req, res) => {
+  const blogId = req.params.id;
+  const content = req.body.comment;
+
+  const blog = await Blog.findById(blogId);
+
+  if (!content) res.status(400).end();
+
+  const comment = new Comment({
+    content,
+    blog: blogId,
+  });
+
+  const savedComment = await comment.save();
+  blog.comments = [...blog.comments, comment._id];
+  await blog.save();
+  res.status(201).json(savedComment);
+});
+
+module.exports = blogRouter;

part7/extended-blog/controllers/login.js

@@ -0,0 +1,29 @@
+require("dotenv").config();
+const router = require("express").Router();
+const jwt = require("jsonwebtoken");
+const bcrypt = require("bcrypt");
+const User = require("../models/user");
+
+router.route("/").post(async (req, res) => {
+  const { username, password } = req.body;
+
+  const user = await User.findOne({ username });
+  const verifyPassword =
+    user !== null && (await bcrypt.compare(password, user.passwordHash));
+
+  if (!(user && verifyPassword)) {
+    return res.status(401).json({
+      error: "invalid username or password",
+    });
+  }
+
+  const token = jwt.sign(
+    { username: user.username, id: user._id },
+    process.env.SECRET,
+    { expiresIn: "1hr" }
+  );
+
+  res.status(200).send({ token, username: user.username, name: user.name });
+});
+
+module.exports = router;

part7/extended-blog/controllers/testing.js

@@ -0,0 +1,12 @@
+var router = require("express").Router();
+var Blog = require("../models/blog");
+var User = require("../models/user");
+
+router.post("/reset", async (req, res) => {
+  await Blog.deleteMany({});
+  await User.deleteMany({});
+
+  res.status(204).end();
+});
+
+module.exports = router;

part7/extended-blog/controllers/users.js

@@ -0,0 +1,33 @@
+const router = require("express").Router();
+const User = require("../models/user");
+const bcrypt = require("bcrypt");
+
+router
+  .route("/")
+  .get(async (req, res) => {
+    const users = await User.find({}).populate("blogs");
+    res.json(users);
+  })
+  .post(async (req, res) => {
+    const salt = await bcrypt.genSalt(10);
+    const passwordHash = await bcrypt.hash(req.body.password, salt);
+
+    const newUser = new User({
+      ...req.body,
+      passwordHash,
+    });
+    const result = await newUser.save();
+
+    res.status(201).json(result);
+  });
+
+router.route("/:id").get(async (req, res) => {
+  const user = await User.findById(req.params.id).populate("blogs");
+  if (user) {
+    res.json(user.toJSON());
+  } else {
+    res.status(404).end();
+  }
+});
+
+module.exports = router;

part7/extended-blog/index.js

@@ -0,0 +1,7 @@
+const app = require("./app");
+const logger = require("./utils/logger")
+const config = require("./utils/config")
+
+app.listen(config.PORT, () => {
+  logger.info(`Server running on port ${config.PORT}`);
+});

part7/extended-blog/jest.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  testEnvironment: "node",
+};

part7/extended-blog/models/blog.js

@@ -0,0 +1,26 @@
+const mongoose = require("mongoose");
+const uniqueValidator = require("mongoose-unique-validator");
+
+const blogSchema = new mongoose.Schema({
+  title: { type: String },
+  author: { type: String },
+  url: String,
+  likes: { type: Number },
+  comments: [{ type: mongoose.Schema.Types.ObjectId, ref: "Comment" }],
+  user: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "User",
+  },
+});
+
+blogSchema.plugin(uniqueValidator);
+
+blogSchema.set("toJSON", {
+  transform: (document, returnedObject) => {
+    returnedObject.id = returnedObject._id.toString();
+    delete returnedObject._id;
+    delete returnedObject.__v;
+  },
+});
+
+module.exports = mongoose.model("Blog", blogSchema);

part7/extended-blog/models/comment.js

@@ -0,0 +1,25 @@
+const mongoose = require("mongoose");
+const uniqueValidator = require("mongoose-unique-validator");
+
+const commentSchema = new mongoose.Schema(
+  {
+    content: String,
+    blog: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Blog",
+    },
+  },
+  { timestamps: true }
+);
+
+commentSchema.plugin(uniqueValidator);
+
+commentSchema.set("toJSON", {
+  transform: (document, returnedObject) => {
+    returnedObject.id = returnedObject._id.toString();
+    delete returnedObject._id;
+    delete returnedObject.__v;
+  },
+});
+
+module.exports = mongoose.model("Comment", commentSchema);

part7/extended-blog/models/user.js

@@ -0,0 +1,29 @@
+const mongoose = require("mongoose");
+const uniqueValidator = require("mongoose-unique-validator");
+
+const userSchema = new mongoose.Schema({
+  username: { type: String, unique: true },
+  passwordHash: String,
+  name: { type: String, minLength: 4 },
+  blogs: [
+    {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Blog",
+    },
+  ],
+});
+
+userSchema.plugin(uniqueValidator, {
+  message: "Error, {PATH} already exist.",
+});
+userSchema.set("toJSON", {
+  transform: (document, returnedObject) => {
+    returnedObject.id = returnedObject._id.toString();
+    delete returnedObject._id;
+    delete returnedObject.__v;
+    // the passwordHash should not be revealed
+    delete returnedObject.passwordHash;
+  },
+});
+
+module.exports = mongoose.model("User", userSchema);