Code Challenge - MERN Project

.gitignore

@@ -0,0 +1,25 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+
+# testing
+/coverage
+
+# production
+/build
+
+# misc
+.DS_Store
+.env.local
+.env.development.local
+.env.testt.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+/.idea/

api/config/config.js

@@ -0,0 +1,24 @@
+const express = require('express')
+const apiRoutes = require('../routing/api-routes')
+const bodyParser = require('body-parser')
+const cors = require('cors')
+const cookieParser = require('cookie-parser')
+
+module.exports = app => {
+    app.set('port', process.env.PORT || 3001)
+
+    app.use(bodyParser.json({limit: '50mb'}))
+    app.use(bodyParser.urlencoded({limit: '50mb', extended: true}))
+    app.use(cookieParser())
+    app.use(express.json())
+    app.use(cors())
+
+    app.use((req, res, next) => {
+        res.header('Access-Control-Allow-Origin', "*")
+        res.header('Access-Control-Allow-Headers', "Origin, X-Requested-With, Content-Type, Accept")
+        next()
+    })
+
+    apiRoutes(app)
+    return app
+}

api/config/database.js

@@ -0,0 +1,9 @@
+const mongoose = require('mongoose')
+const database = require('./index')
+
+mongoose.connect(database.url, {
+    useNewUrlParser: true,
+    useUnifiedTopology: true
+})
+    .then(() => console.log('App Connected to Database!'))
+    .catch(() => console.log('err'))

api/config/index.js

@@ -0,0 +1,5 @@
+const mongoConfig = {
+    url: `mongodb://localhost/mern_project`,
+}
+
+module.exports = mongoConfig

api/controllers/item.controller.js

@@ -0,0 +1,93 @@
+let Item = require('../models/item.model')
+const getErrorMessage = require('../shared/index')
+
+exports.index = function (req, res) {
+    try {
+        Item.get(function (err, items) {
+            if (err)
+                throw new Error('')
+
+            res.status(200).json({
+                message: 'Items retrieved successfully',
+                data: items
+            })
+        })
+    } catch (e) {
+        res.status(500).json(getErrorMessage(' retrieving items'))
+    }
+}
+
+exports.new = async (req, res) => {
+    try {
+        let NewItem = new Item()
+        NewItem.listId = req.body.listId
+        NewItem.name = req.body.name
+        NewItem.date = req.body.date
+
+        const result = await NewItem.save()
+        res.status(200).json({
+            message: 'New item saved',
+            data: result
+        })
+    } catch (e) {
+        res.status(500).json(getErrorMessage('creating the item'))
+    }
+}
+
+exports.view = function (req, res) {
+    try {
+        Item.findById(req.body.itemId, function (err, item) {
+            if (err)
+                throw new Error('')
+
+            res.status(200).json({
+                message: 'Item information',
+                data: item
+            })
+        })
+    } catch (e) {
+        res.status(500).json(getErrorMessage('retrieving the item information'))
+    }
+}
+
+exports.update = function (req, res) {
+    try {
+        Item.findById(req.body.itemId, function (err, item) {
+            if (err)
+                throw new Error('')
+
+            item.name = req.body.name ? req.body.name : item.name
+            item.date = req.body.date ? req.body.date : item.date
+
+            item.save(function (err) {
+                if (err)
+                    throw new Error('')
+
+                res.status(200).json({
+                    message: 'Item name updated',
+                    data: item
+                })
+            })
+        })
+    } catch (e) {
+        res.status(500).json(getErrorMessage('updating the item information'))
+    }
+}
+
+exports.delete = function (req, res) {
+    try {
+        Item.remove({
+            _id: req.body.itemId
+        }, function (err) {
+            if (err)
+                throw new Error('')
+
+            res.json({
+                status: 'success',
+                message: 'Item deleted'
+            })
+        })
+    } catch (e) {
+        res.status(500).json(getErrorMessage('deleting the item'))
+    }
+}

api/controllers/list.controller.js

@@ -0,0 +1,94 @@
+let List = require('../models/list.model')
+let Item = require('../models/item.model')
+const { map } = require('awaity')
+const getErrorMessage = require('../shared/index')
+
+exports.index = async (req, res) => {
+    try {
+        let lists = await List.find({})
+        const newLists = await map(lists, async list => {
+            const children = await Item.find({listId: list._id})
+            return {...list.toObject(), items: children}
+        })
+
+        res.status(200).json({
+            message: 'Lists retrieved successfully',
+            data: newLists
+        })
+    } catch (e) {
+        res.status(500).json(getErrorMessage(' retrieving lists'))
+    }
+}
+
+exports.new = async (req, res) => {
+    try {
+        const name = req.body.name
+        let NewList = new List()
+        NewList.name = name
+
+        const result = await NewList.save()
+        res.status(200).json({
+            message: 'New list saved',
+            data: result
+        })
+    } catch (e){
+        res.status(500).json(getErrorMessage('creating the list'))
+    }
+}
+
+exports.view = function (req, res) {
+    try {
+        List.findById(req.body.listId, function (err, list) {
+            if (err)
+                throw new Error('')
+            res.status(200).json({
+                message: 'List information',
+                data: list
+            })
+        })
+    } catch (e) {
+        res.status(500).json(getErrorMessage('retrieving the list information'))
+    }
+}
+
+exports.update = function (req, res) {
+    try {
+        List.findById(req.body.listId, function (err, list) {
+            if (err)
+                throw new Error('')
+
+            list.name = req.body.name ? req.body.name : list.name
+
+            list.save(function (err) {
+                if (err)
+                    throw new Error('')
+
+                res.status(200).json({
+                    message: 'List name updated',
+                    data: list
+                })
+            })
+        })
+    } catch (e) {
+        res.status(500).json(getErrorMessage('updating the list information'))
+    }
+}
+
+exports.delete = function (req, res) {
+    try {
+        List.remove({
+            _id: req.body.listId
+
+        }, function (err) {
+            if (err)
+                throw new Error('')
+
+            res.json({
+                status: 'success',
+                message: 'List deleted'
+            })
+        })
+    } catch (e) {
+        res.status(500).json(getErrorMessage('deleting the list'))
+    }
+}

api/controllers/tests/item.controller.test.js

@@ -0,0 +1,20 @@
+const app = require('../../index')
+const supertest = require('supertest')
+const request = supertest(app)
+
+app.set('port', process.env.PORT || 3002)
+
+describe('Test suite for Items', () => {
+    it('Getting all items returns Status 200', async (done) => {
+        const res = await request.get('/api/items')
+        expect(res.status).toBe(200)
+        done()
+    })
+
+    it('Getting all items', async (done) => {
+        const res = await request.get('/api/items')
+        expect(res.body.message).toBe('Items retrieved successfully')
+        expect(Array.isArray(res.body.data)).toBe(true)
+        done()
+    })
+})

api/controllers/tests/list.controller.test.js

@@ -0,0 +1,38 @@
+const app = require('../../index')
+const supertest = require('supertest')
+const request = supertest(app)
+
+app.set('port', process.env.PORT || 3003)
+
+describe('Test suite for Lists', () => {
+    it('Getting all lists returns Status 200', async (done) => {
+        const res = await request.get('/api/lists')
+        expect(res.status).toBe(200)
+        done()
+    })
+
+    it('Getting all lists', async (done) => {
+        const res = await request.get('/api/lists')
+        expect(res.body.message).toBe('Lists retrieved successfully')
+        expect(Array.isArray(res.body.data)).toBe(true)
+        done()
+    })
+
+    it('Should post a new list', async (done) => {
+        let data = {
+            'name': 'the list name'
+        }
+
+        const res = await request
+            .post('/api/lists')
+            .send(data)
+            .set('Accept', 'application/json')
+            .expect('Content-Type', /json/)
+            .expect(200 || 201)
+            .end((err) => {
+                if (err) return done(err);
+                done();
+            });
+
+    })
+})

api/index.js

@@ -0,0 +1,11 @@
+const express = require('express')
+const config = require('./config/config')
+
+require('./config/database')
+const app = config(express())
+
+app.listen(app.get('port'), () => {
+    console.log("Running MERN Backend on port " + app.get('port'))
+})
+
+module.exports = app

api/models/item.model.js

@@ -0,0 +1,15 @@
+const mongoose = require('mongoose')
+
+const ItemSchema = mongoose.Schema({
+        listId: { type: String, required: true },
+        name: { type: String, required: true },
+        date: { type: Date, required: true }
+    },
+    { writeConcern: { w: "majority" , wtimeout: 5000 }}
+)
+
+// Export Message model
+var Item = module.exports = mongoose.model('Item', ItemSchema);
+module.exports.get = function (callback, limit) {
+    Item.find(callback).limit(limit);
+}

api/models/list.model.js

@@ -0,0 +1,13 @@
+const mongoose = require('mongoose')
+
+const ListSchema = mongoose.Schema({
+    name: { type: String, required: true }
+},
+    { writeConcern: { w: "majority" , wtimeout: 5000 }}
+)
+
+// Export Message model
+var List = module.exports = mongoose.model('List', ListSchema);
+module.exports.get = function (callback, limit) {
+    List.find(callback).limit(limit);
+}

api/routing/api-routes.js

@@ -0,0 +1,33 @@
+let router = require('express').Router()
+let listController = require('../controllers/list.controller')
+let itemController = require('../controllers/item.controller')
+
+const authMiddleware = async (req, res, next) => {
+    const {cookies: {auth = null}} = req
+    if (auth) {
+        console.log(`Auth Cookie received, value: ${auth}`)
+        next()
+    } else res.status(401).send({message: 'Auth Failed'})
+}
+
+module.exports = app => {
+    router.get('/lists', listController.index)
+    router.post('/lists', listController.new)
+    router.get('/lists/list', listController.view)
+    router.patch('/lists', listController.update)
+    router.put('/lists', listController.update)
+    router.delete('/lists', listController.delete)
+
+    router.get('/items', itemController.index)
+    router.post('/items', itemController.new)
+    router.get('/items/item', itemController.view)
+    router.patch('/items', itemController.update)
+    router.put('/items', itemController.update)
+    router.delete('/items', itemController.delete)
+
+    // Without cookie checking
+    app.use('/api', router)
+
+    // To check for cookie in the request:
+    // app.use('/api', authMiddleware, router)
+}

api/shared/index.js

@@ -0,0 +1,5 @@
+module.exports = action => {
+    return {
+        message: `Something went wrong while ${action}`
+    }
+}