@paralect/hive 0.0.1

package/starter/src/routes/index.js

@@ -0,0 +1,151 @@
+const _ = require("lodash");
+
+const getResources = require("helpers/getResources");
+const getResourceEndpoints = require("helpers/getResourceEndpoints");
+
+const mount = require("koa-mount");
+const Router = require("@koa/router");
+const validate = require("middlewares/validate");
+
+const requestLogService = require("db").createService("_request_logs");
+
+const tryToAttachUser = require("middlewares/global/tryToAttachUser");
+
+const attachCustomErrors = require("./middlewares/attachCustomErrors");
+const routeErrorHandler = require("./middlewares/routeErrorHandler");
+
+const logRequestToMongo = async (ctx, next) => {
+  const startedOn = new Date();
+
+  const saveLog = async ({ error = null } = {}) => {
+    if (ctx.state.resourceName && ctx.state.endpoint) {
+      const requestLog = {
+        isSuccess: true,
+
+        request: {
+          url: ctx.originalUrl,
+          method: ctx.request.method,
+
+          query: ctx.query,
+          body: ctx.request.body,
+          params: ctx.params,
+          headers: ctx.headers,
+        },
+
+        response: {
+          status: ctx.status,
+          body: ctx.body,
+        },
+
+        resourceName: ctx.state.resourceName,
+        endpoint: ctx.state.endpoint,
+
+        time: new Date() - startedOn,
+      };
+
+      if (error) {
+        requestLog.isSuccess = false;
+
+        requestLog.error = {
+          message: error.message,
+          stack: error.stack,
+        };
+      }
+
+      await requestLogService.create(requestLog);
+    }
+  };
+
+  try {
+    await next();
+    await saveLog({ error: ctx.state.error });
+  } catch (err) {
+    await saveLog({ error: err });
+
+    throw err;
+  }
+};
+
+const defineRoutes = async (app) => {
+  app.use(logRequestToMongo);
+  app.use(attachCustomErrors);
+  app.use(routeErrorHandler);
+
+  app.use(tryToAttachUser);
+
+  const resources = await getResources();
+
+  _.each(resources, async ({ name: resourceName }) => {
+    const resourceRouter = new Router();
+    const globalRouter = new Router();
+
+    const endpoints = (await getResourceEndpoints(resourceName))
+      .map(({ file: endpointFile, name }) => {
+        const {
+          endpoint = { method: 'get', url: '/' },
+          requestSchema,
+          middlewares = [],
+          handler,
+        } = require(endpointFile);
+
+        endpoint.name = name;
+
+        return {
+          endpoint,
+          requestSchema,
+          middlewares,
+          handler,
+        };
+      })
+      .sort((e) => {
+        e.endpoint = e.endpoint || { method: 'get', url: '/' };
+
+        const url = e.endpoint.url || e.endpoint.absoluteUrl;
+
+        if (url.includes("/:")) {
+          return 1;
+        }
+        return -1;
+      });
+
+
+    endpoints.forEach(({ endpoint, requestSchema, middlewares, handler }) => {
+      const additionalMiddlewares = [];
+
+      if (requestSchema) {
+        additionalMiddlewares.push(validate(requestSchema));
+      }
+
+      let targetRouter;
+      let url = endpoint.absoluteUrl || endpoint.url;
+
+      if (url.startsWith("$HOST/")) {
+        url = url.replace("$HOST", "");
+        targetRouter = globalRouter;
+      } else if (endpoint.absoluteUrl) {
+        targetRouter = globalRouter;
+      } else {
+        targetRouter = resourceRouter;
+      }
+
+      targetRouter[endpoint.method?.toLowerCase() || "get"](
+        url,
+        async (ctx, next) => {
+          ctx.state.resourceName = resourceName;
+          ctx.state.endpoint = endpoint;
+
+          await next();
+        },
+        ...additionalMiddlewares,
+        ...middlewares,
+        handler
+      );
+    });
+
+    app.use(globalRouter.routes());
+
+    app.use(mount(`/${resourceName}`, resourceRouter.routes()));
+  });
+};
+
+module.exports = defineRoutes;

package/starter/src/routes/middlewares/attachCustomErrors.js

@@ -0,0 +1,28 @@
+const _ = require("lodash");
+
+const formatError = (customError) => {
+  const errors = {};
+
+  Object.keys(customError).forEach((key) => {
+    errors[key] = _.isArray(customError[key])
+      ? customError[key]
+      : [customError[key]];
+  });
+
+  return errors;
+};
+
+const attachCustomErrors = async (ctx, next) => {
+  ctx.throwError = (message) => ctx.throw(500, { message });
+  ctx.assertError = (condition, message) =>
+    ctx.assert(condition, 500, { message });
+
+  ctx.throwClientError = (errors) =>
+    ctx.throw(400, { errors: formatError(errors) });
+  ctx.assertClientError = (condition, errors) =>
+    ctx.assert(condition, 400, { errors: formatError(errors) });
+
+  await next();
+};
+
+module.exports = attachCustomErrors;

package/starter/src/routes/middlewares/routeErrorHandler.js

@@ -0,0 +1,27 @@
+const logger = require("logger");
+
+const routeErrorHandler = async (ctx, next) => {
+  try {
+    await next();
+  } catch (error) {
+    const clientError = error.errors;
+    const serverError = { global: error.message };
+
+    const errors = clientError || serverError;
+
+    console.log("Route Error", errors);
+
+    logger.error(errors);
+
+    if (serverError && process.env.APP_ENV === "production") {
+      serverError.global = "Something went wrong";
+    }
+
+    ctx.state.error = error;
+
+    ctx.status = error.status || 500;
+    ctx.body = { errors };
+  }
+};
+
+module.exports = routeErrorHandler;

package/starter/src/scheduler/handlers/sendDailyReport.example.js

@@ -0,0 +1,7 @@
+const moment = require("moment");
+
+module.exports.cron = "* * * * *";
+
+module.exports.handler = () => {
+  const yesterday = moment().add(-1, "day").toDate();
+};

package/starter/src/scheduler.js

@@ -0,0 +1,21 @@
+const moment = require("moment");
+const schedule = require("node-schedule");
+
+const requireDir = require("require-dir");
+
+requireDir("scheduler/handlers", {
+  mapValue: (handler, handlerName) => {
+    console.log(
+      `[scheduler] Registering handler ${handlerName} with cron ${handler.cron}`
+    );
+
+    schedule.scheduleJob(handler.cron, () => {
+      console.log(
+        `[scheduler] ${moment().format()} executing ${handlerName} with cron ${
+          handler.cron
+        }`
+      );
+      handler.handler();
+    });
+  },
+});

package/starter/src/security.util.js

@@ -0,0 +1,38 @@
+const crypto = require("crypto");
+const bcrypt = require("bcryptjs");
+const util = require("util");
+
+const randomBytes = util.promisify(crypto.randomBytes, crypto);
+const bcryptHash = util.promisify(bcrypt.hash, bcrypt);
+const compare = util.promisify(bcrypt.compare, bcrypt);
+
+/**
+ * @desc Generates random string, useful for creating secure tokens
+ *
+ * @return {string} - random string
+ */
+exports.generateSecureToken = async (tokenLength = 48) => {
+  const buf = await randomBytes(tokenLength);
+  return buf.toString("hex");
+};
+
+/**
+ * @desc Generate hash from any string. Could be used to generate a hash from password
+ *
+ * @param text {string} - a text to produce hash from
+ * @return {Promise} - a hash from input text
+ */
+exports.getHash = (text) => {
+  return bcryptHash(text, 10);
+};
+
+/**
+ * @desc Compares if text and hash are equal
+ *
+ * @param text {string} - a text to compare with hash
+ * @param hash {string} - a hash to compare with text
+ * @return {Promise} - are hash and text equal
+ */
+exports.compareTextWithHash = (text, hash) => {
+  return compare(text, hash);
+};

package/starter/src/socketIo.js

@@ -0,0 +1,91 @@
+const { Server } = require("socket.io");
+const { createClient } = require("redis");
+const { createAdapter } = require("@socket.io/redis-adapter");
+
+const config = require("config");
+const logger = require("logger");
+
+module.exports = (server) => {
+  const io = new Server(server);
+
+  const pubClient = createClient({ url: config.redis.url });
+  const subClient = pubClient.duplicate();
+
+  io.adapter(createAdapter(pubClient, subClient));
+
+  const getCookie = (cookieString, name) => {
+    const value = `; ${cookieString}`;
+    const parts = value.split(`; ${name}=`);
+
+    if (parts.length === 2) {
+      return parts.pop().split(";").shift();
+    }
+
+    return null;
+  };
+
+  // #TODO get user using accessToken
+  const getUserData = async (socket) => {
+    const accessToken = getCookie(
+      socket.handshake.headers.cookie,
+      "ship_access_token"
+    );
+
+    if (!accessToken) {
+      logger.info(
+        "Note: socket io anonymous auth. Add user authentication in socketIoService"
+      );
+    }
+
+    return {
+      _id: "anonymous",
+    };
+  };
+
+  io.use(async (socket, next) => {
+    const userData = await getUserData(socket);
+
+    if (userData) {
+      // eslint-disable-next-line no-param-reassign
+      socket.handshake.data = {
+        userId: userData.userId,
+      };
+
+      return next();
+    }
+
+    return next(new Error("token is invalid"));
+  });
+
+  function checkAccessToRoom(roomId, data) {
+    let result = false;
+    const [roomType, id] = roomId.split("-");
+
+    switch (roomType) {
+      case "user":
+        result = id === data.userId;
+        break;
+      default:
+        result = true;
+    }
+
+    return result;
+  }
+
+  io.on("connection", (client) => {
+    client.on("subscribe", (roomId) => {
+      const { userId } = client.handshake.data;
+      const hasAccessToRoom = checkAccessToRoom(roomId, { userId });
+
+      if (hasAccessToRoom) {
+        client.join(roomId);
+      }
+    });
+
+    client.on("unsubscribe", (roomId) => {
+      client.leave(roomId);
+    });
+  });
+
+  console.log(`Socket.io server is started on app instance`);
+};