@paralect/hive 0.0.1

package/starter/src/logger.js

@@ -0,0 +1,30 @@
+const winston = require("winston");
+const config = require("config");
+
+const colorizer = winston.format.colorize();
+
+const createConsoleLogger = () => {
+  // eslint-disable-next-line new-cap
+  const logger = new winston.createLogger({
+    exitOnError: false,
+    level: config.isDev ? "debug" : "info",
+    format: winston.format.combine(
+      winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+      config.isDev
+        ? winston.format.printf((msg) =>
+            colorizer.colorize(
+              msg.level,
+              `${msg.timestamp} - ${msg.level}: ${JSON.stringify(msg.message)}`
+            )
+          )
+        : winston.format.json()
+    ),
+    transports: [new winston.transports.Console()],
+  });
+
+  logger.debug("[logger] Configured console based logger");
+
+  return logger;
+};
+
+module.exports = createConsoleLogger();

package/starter/src/middlewares/global/extractUserTokens.js

@@ -0,0 +1,15 @@
+const storeTokenToState = async (ctx, next) => {
+  let accessToken = ctx.cookies.get("ship_access_token");
+
+  const { authorization } = ctx.headers;
+
+  if (!accessToken && authorization) {
+    accessToken = authorization.replace("Bearer", "").trim();
+  }
+
+  ctx.state.accessToken = accessToken;
+
+  await next();
+};
+
+module.exports = storeTokenToState;

package/starter/src/middlewares/global/tryToAttachUser.js

@@ -0,0 +1,32 @@
+const userService = require("db").services.users;
+const tokenService = require("db").services.tokens;
+
+const storeTokenToState = async (ctx) => {
+  let accessToken = ctx.cookies.get("access_token");
+
+  const { authorization } = ctx.headers;
+
+  if (!accessToken && authorization) {
+    accessToken = authorization.replace("Bearer", "").trim();
+  }
+
+  ctx.state.accessToken = accessToken;
+};
+
+const tryToAttachUser = async (ctx, next) => {
+  storeTokenToState(ctx);
+
+  // let token;
+
+  // if (ctx.state.accessToken) {
+  //   token = await tokenService.findOne({ token: ctx.state.accessToken });
+  // }
+
+  // if (token) {
+  //   ctx.state.user = await userService.findOne({ _id: token.user._id });
+  // }
+
+  return next();
+};
+
+module.exports = tryToAttachUser;

package/starter/src/middlewares/isAuthorized.js

@@ -0,0 +1,9 @@
+module.exports = (ctx, next) => {
+  if (ctx.state.user) {
+    return next();
+  }
+
+  ctx.status = 401;
+  ctx.body = {};
+  return null;
+};

package/starter/src/middlewares/shouldExist.js

@@ -0,0 +1,17 @@
+const db = require("db");
+
+module.exports = (
+  resourceName,
+  { criteria = (ctx) => ({ _id: ctx.params[`${resourceName}Id`] }) } = {}
+) => {
+  return async (ctx, next) => {
+    const doc = await db.services[resourceName].findOne(criteria(ctx));
+    ctx.state[resourceName] = doc;
+
+    if (!doc) {
+      ctx.throw(404, { message: `${resourceName} not found` });
+    } else {
+      await next();
+    }
+  };
+};

package/starter/src/middlewares/shouldNotExist.js

@@ -0,0 +1,19 @@
+const _ = require("lodash");
+const db = require("db");
+
+module.exports = (
+  resourceName,
+  { criteria = (ctx) => ({ name: ctx.validatedData.name }) } = {}
+) => {
+  return async (ctx, next) => {
+    const doc = await db.services[resourceName].findOne(criteria(ctx));
+
+    if (doc) {
+      ctx.throw(400, {
+        message: `${_.capitalize(resourceName)} already exists`,
+      });
+    } else {
+      await next();
+    }
+  };
+};

package/starter/src/middlewares/uploadFile.js

@@ -0,0 +1,5 @@
+const multer = require("@koa/multer");
+
+const storage = multer.memoryStorage();
+
+module.exports = multer({ storage });

package/starter/src/middlewares/validate.js

@@ -0,0 +1,39 @@
+const Joi = require("joi");
+
+function formatError(joiError) {
+  const errors = {};
+
+  joiError.details.forEach((error) => {
+    const key = error.path.join(".");
+    errors[key] = errors[key] || [];
+    errors[key].push(error.message);
+  });
+
+  return errors;
+}
+
+function validate(schema) {
+  return async (ctx, next) => {
+    if (!schema.validate) {
+      schema = Joi.object(schema);
+    }
+
+    const { value, error } = await schema.validate(
+      {
+        ...ctx.request.body,
+        ...ctx.query,
+      },
+      {
+        abortEarly: false,
+        allowUnknown: true,
+      }
+    );
+
+    if (error) ctx.throw(400, { errors: formatError(error) });
+
+    ctx.validatedData = value;
+    await next();
+  };
+}
+
+module.exports = validate;

package/starter/src/migrations/migration.js

@@ -0,0 +1,8 @@
+class Migration {
+  constructor(version, description) {
+    this.version = version;
+    this.description = description;
+  }
+}
+
+module.exports = Migration;

package/starter/src/migrations/migration.service.js

@@ -0,0 +1,75 @@
+const db = require("db");
+const fs = require("fs");
+const path = require("path");
+const _ = require("lodash");
+const validateSchema = require("./migrations.schema");
+
+const service = db.createService("__migrationVersion", {
+  validate: validateSchema,
+});
+const migrationsPath = path.join(__dirname, "migrations");
+const _id = "migration_version";
+
+const getMigrationNames = () =>
+  new Promise((resolve, reject) => {
+    fs.readdir(migrationsPath, (err, files) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve(files);
+    });
+  });
+
+service.getCurrentMigrationVersion = () =>
+  service.findOne({ _id }).then((doc) => {
+    if (!doc) {
+      return 0;
+    }
+
+    return doc.version;
+  });
+
+service.getMigrations = () => {
+  let migrations = null;
+
+  return getMigrationNames()
+    .then((names) => {
+      migrations = names.map((name) => {
+        const migrationPath = path.join(migrationsPath, name);
+        // eslint-disable-next-line import/no-dynamic-require, global-require
+        return require(migrationPath);
+      });
+
+      return migrations;
+    })
+    .catch((err) => {
+      throw err;
+    });
+};
+
+service.setNewMigrationVersion = (version) =>
+  service.atomic.findOneAndUpdate(
+    { _id },
+    {
+      $set: {
+        version,
+      },
+      $setOnInsert: {
+        _id,
+      },
+    },
+    { upsert: true }
+  );
+
+service.promiseLimit = (documents = [], limit, operator) => {
+  const chunks = _.chunk(documents, limit);
+
+  return chunks.reduce((init, chunk) => {
+    return init.then(() => {
+      return Promise.all(chunk.map((c) => operator(c)));
+    });
+  }, Promise.resolve());
+};
+
+module.exports = service;

package/starter/src/migrations/migrations/1.js

@@ -0,0 +1,22 @@
+const Migration = require("migrations/migration");
+// const migrationService = require('migrations/migration.service');
+//
+// const userService = require('resources/user/user.service');
+
+const migration = new Migration(1, "Example");
+
+migration.migrate = async () => {
+  // const userIds = await userService.distinct('_id', {
+  //   isEmailVerified: true,
+  // });
+  //
+  // await migrationService.promiseLimit(userIds, 50, (userId) => userService.updateOne(
+  //   { _id: userId },
+  //   (old) => ({
+  //     ...old,
+  //     isEmailVerified: false,
+  //   }),
+  // ));
+};
+
+module.exports = migration;

package/starter/src/migrations/migrations-log/migration-log.schema.js

@@ -0,0 +1,15 @@
+const Joi = require("joi");
+
+const schema = Joi.object({
+  _id: Joi.string(),
+  createdOn: Joi.date(),
+  updatedOn: Joi.date(),
+  startTime: Joi.date().required(),
+  finishTime: Joi.date(),
+  status: Joi.string().required(),
+  error: Joi.string(),
+  errorStack: Joi.string(),
+  duration: Joi.string(),
+  migrationVersion: Joi.number().required(),
+});
+module.exports = schema;

package/starter/src/migrations/migrations-log/migration-log.service.js

@@ -0,0 +1,51 @@
+const db = require("db");
+
+const validateSchema = require("./migration-log.schema.js");
+
+const service = db.createService("__migrationLog", {
+  validate: validateSchema,
+});
+
+service.startMigrationLog = (_id, startTime, migrationVersion) => {
+  return service.atomic.findOneAndUpdate(
+    { _id },
+    {
+      $set: {
+        migrationVersion,
+        startTime,
+        status: "running",
+      },
+      $setOnInsert: {
+        _id,
+      },
+    },
+    { upsert: true }
+  );
+};
+
+service.failMigrationLog = (_id, finishTime, err) =>
+  service.atomic.update(
+    { _id },
+    {
+      $set: {
+        finishTime,
+        status: "failed",
+        error: err.message,
+        errorStack: err.stack,
+      },
+    }
+  );
+
+service.finishMigrationLog = (_id, finishTime, duration) =>
+  service.atomic.update(
+    { _id },
+    {
+      $set: {
+        finishTime,
+        status: "completed",
+        duration,
+      },
+    }
+  );
+
+module.exports = service;

package/starter/src/migrations/migrations.schema.js

@@ -0,0 +1,9 @@
+const Joi = require("joi");
+
+const schema = Joi.object({
+  _id: Joi.string(),
+  createdOn: Joi.date(),
+  updatedOn: Joi.date(),
+  version: Joi.number().required(),
+});
+module.exports = schema;

package/starter/src/migrations/migrator.js

@@ -0,0 +1,77 @@
+require("moment-duration-format");
+const moment = require("moment");
+
+const logger = require("logger");
+
+const migrationLogService = require("./migrations-log/migration-log.service");
+const migrationService = require("./migration.service");
+
+const migrator = {};
+
+const run = async (migrations, curVersion) => {
+  const newMigrations = migrations
+    .filter((migration) => migration.version > curVersion)
+    .sort((a, b) => a.version - b.version);
+
+  if (!newMigrations.length) {
+    logger.info(`No new migrations found, stopping the process.
+      Current database version is ${curVersion}`);
+    return;
+  }
+
+  let migrationLogId;
+  let migration;
+  let lastMigrationVersion;
+
+  try {
+    for (migration of newMigrations) {
+      //eslint-disable-line
+      migrationLogId = migrationService.generateId();
+      const startTime = new Date();
+      await migrationLogService.startMigrationLog(
+        migrationLogId,
+        startTime,
+        migration.version
+      ); //eslint-disable-line
+      logger.info(
+        `Migration #${migration.version} is running: ${migration.description}`
+      );
+      await migration.migrate(); //eslint-disable-line
+
+      lastMigrationVersion = migration.version;
+      await migrationService.setNewMigrationVersion(migration.version); //eslint-disable-line
+      const finishTime = new Date();
+      const duration = moment
+        .duration(finishTime - startTime)
+        .format("h [hrs], m [min], s [sec], S [ms]");
+
+      await migrationLogService.finishMigrationLog(
+        migrationLogId,
+        finishTime,
+        duration
+      ); //eslint-disable-line
+      logger.info(
+        `Database has been updated to the version #${migration.version}`
+      );
+      logger.info(`Time of migration #${migration.version}: ${duration}`);
+    }
+    logger.info(`All migrations has been finished, stopping the process.
+      Current database version is: ${lastMigrationVersion}`);
+  } catch (err) {
+    logger.error(`Failed to update migration to version ${migration.version}`);
+    logger.error(err);
+    await migrationLogService.failMigrationLog(migrationLogId, new Date(), err);
+    throw err;
+  }
+};
+
+migrator.exec = async () => {
+  const [migrations, currentVersion] = await Promise.all([
+    migrationService.getMigrations(),
+    migrationService.getCurrentMigrationVersion(),
+  ]);
+  await run(migrations, currentVersion);
+  process.exit(0);
+};
+
+module.exports = migrator;

package/starter/src/migrator.js

@@ -0,0 +1,5 @@
+require("app-module-path").addPath(__dirname);
+
+const migrator = require("migrations/migrator");
+
+migrator.exec();

package/starter/src/resources/_dev/endpoints/triggerSchedulerHandler.js

@@ -0,0 +1,30 @@
+const Joi = require("joi");
+
+module.exports.endpoint = {
+  method: "put",
+  url: "/trigger-scheduler-handler",
+};
+
+module.exports.requestSchema = {
+  name: Joi.string().required(),
+};
+
+module.exports.handler = async (ctx) => {
+  const { name } = ctx.validatedData;
+
+  const schedulerHandler = require(`scheduler/handlers/${name}`);
+
+  try {
+    const data = await schedulerHandler.handler();
+
+    ctx.body = {
+      ok: true,
+      data,
+    };
+  } catch (err) {
+    ctx.body = {
+      ok: false,
+      err: err.message,
+    };
+  }
+};

package/starter/src/resources/health/endpoints/get.js

@@ -0,0 +1,10 @@
+const handler = (ctx) => {
+  ctx.status = 200;
+};
+
+module.exports.handler = handler;
+
+module.exports.endpoint = {
+  method: "get",
+  url: "/",
+};

package/starter/src/resources/schemaMappings/schemaMappings.schema.js

@@ -0,0 +1,9 @@
+const Joi = require('joi');
+
+module.exports = Joi.object({
+  _id: Joi.string(),
+  createdOn: Joi.date(),
+  updatedOn: Joi.date(),
+
+  mappings: Joi.object(),
+});

package/starter/src/resources/users/endpoints/getCurrentUser.js

@@ -0,0 +1,13 @@
+module.exports.handler = async (ctx) => {
+  const user = await userService.findOne({ _id: ctx.state.user._id });
+  ctx.body = user;
+};
+
+const Joi = require("joi");
+
+module.exports.requestSchema = Joi.object({});
+
+module.exports.endpoint = {
+  method: "GET",
+  url: "/me",
+};

package/starter/src/resources/users/endpoints/getUserProfile.js

@@ -0,0 +1,16 @@
+module.exports.handler = async (ctx) => {
+  const { userId } = ctx.params;
+  const user = await userService.findOne({ _id: userId });
+  ctx.body = user;
+};
+
+const Joi = require("joi");
+
+module.exports.requestSchema = Joi.object({
+  userId: Joi.string().required(),
+});
+
+module.exports.endpoint = {
+  method: "GET",
+  url: "/profile/:userId",
+};

package/starter/src/resources/users/users.schema.js

@@ -0,0 +1,14 @@
+const Joi = require("joi");
+
+const users = Joi.object({
+  username: Joi.string().required(),
+  email: Joi.string().email().required(),
+  password: Joi.string().required(),
+  bio: Joi.string(),
+  avatarUrl: Joi.string().uri(),
+  _id: Joi.string(),
+  createdOn: Joi.date(),
+  updatedOn: Joi.date(),
+});
+
+module.exports = users;