most of core structure in place, minus db/models

Author: coreyc

config/config.js

@@ -0,0 +1,13 @@
+const { blogService } = require('../services');
+
+const { requireAuthentication } = auth;
+const { createBlogpost } = blogService;
+
+function postBlogpost(user, content) {
+  requireAuthentication(user);
+  return createBlogpost(user, content);
+}
+
+module.exports = {
+  postBlogpost
+};

controllers/blog-post.controller.js

@@ -0,0 +1,5 @@
+const blogpost = require('./blog-post.controller');
+
+module.exports = {
+  blogpost
+};

controllers/index.js

@@ -0,0 +1,68 @@
+const express = require('express');
+
+const controllers = require('../controllers');
+
+const router = express.Router();
+const {
+  auth,
+  home,
+  publication,
+} = controllers;
+
+/**
+ * Handles controller execution and responds to user (API version).
+ * This way controllers are not attached to the API.
+ * Web socket has a similar handler implementation.
+ * @param promise Controller Promise.
+ * @param params (req) => [params, ...].
+ */
+const controllerHandler = (promise, params) => async (req, res, next) => {
+  const boundParams = params ? params(req, res, next) : [];
+  try {
+    const result = await promise(...boundParams);
+    return res.json(result || { message: 'OK' });
+  } catch (error) {
+    return res.status(500) && next(error);
+  }
+};
+const c = controllerHandler;
+
+/**
+ * Auth.
+ */
+router.post('/signin', c(auth.signin, (req, res, next) => [req, res, next]));
+router.post('/signup', c(auth.signup, (req, res, next) => [req, res, next]));
+
+/**
+ * Home.
+ */
+router.get('/', c(home.hello));
+router.get('/greet/:name', c(home.getGreeting, req => [req.params.name]));
+router.post('/greet/', c(home.postGreeting, req => [req.body.name]));
+
+/**
+ * Publications.
+ */
+router.get('/publications', c(publication.getPublications));
+router.post('/publications', c(publication.postPublication, req => [req.user, req.body.content]));
+
+/**
+ * Error-handler.
+ */
+router.use((err, req, res, _next) => {
+  // Expected errors always throw ServerError.
+  // Unexpected errors will either throw unexpected stuff or crash the application.
+  if (Object.prototype.isPrototypeOf.call(ServerError.prototype, err)) {
+    return res.status(err.status || 500).json({ error: err.message });
+  }
+
+  log.error('~~~ Unexpected error exception start ~~~');
+  log.error(req);
+  log.error(err);
+  log.error('~~~ Unexpected error exception end ~~~');
+
+
+  return res.status(500).json({ error: '⁽ƈ ͡ (ुŏ̥̥̥̥םŏ̥̥̥̥) ु' });
+});
+
+module.exports = router;

models/blog-post.model.js

@@ -0,0 +1,18 @@
+const Post = require('../models/Post');
+
+const createBlogpost = async (user, content) => {
+  const post = new Post();
+  post.user = user;
+  post.content = content;
+
+  try {
+    await post.validate();
+    return post.save();
+  } catch (e) {
+    throw new Error(e.message);
+  }
+}
+
+module.exports = {
+  createBlogpost
+};

routes/index.js

@@ -0,0 +1,5 @@
+const blogService = require('./blog-post.service');
+
+module.exports = {
+  blogService
+};