@paralect/hive 0.1.49 → 0.1.50-alpha.2

package/.hive/src/lib/node-mongo/package.json

@@ -0,0 +1,74 @@
+{
+  "_args": [
+    [
+      "@paralect/node-mongo@2.1.1",
+      "/Users/igorkrasnik/Documents/work/trojanflix-api"
+    ]
+  ],
+  "_from": "@paralect/node-mongo@2.1.1",
+  "_id": "@paralect/node-mongo@2.1.1",
+  "_inBundle": false,
+  "_integrity": "sha512-IneYD4qTa2P0St3m3Zlw/nRXejTsrsepkmEy7Qw0KYjEQeoekr6gxC6edOPouupkQA0qBOUl4zQSdkaEIUn36w==",
+  "_location": "/@paralect/node-mongo",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "@paralect/node-mongo@2.1.1",
+    "name": "@paralect/node-mongo",
+    "escapedName": "@paralect%2fnode-mongo",
+    "scope": "@paralect",
+    "rawSpec": "2.1.1",
+    "saveSpec": null,
+    "fetchSpec": "2.1.1"
+  },
+  "_requiredBy": [
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/@paralect/node-mongo/-/node-mongo-2.1.1.tgz",
+  "_spec": "2.1.1",
+  "_where": "/Users/igorkrasnik/Documents/work/trojanflix-api",
+  "author": {
+    "name": "Paralect"
+  },
+  "bugs": {
+    "url": "https://github.com/paralect/node-mongo/issues"
+  },
+  "dependencies": {
+    "lodash": "4.17.20",
+    "monk": "7.3.2"
+  },
+  "description": "MongoDB wrapper for Node.JS 12",
+  "devDependencies": {
+    "chai": "^4.2.0",
+    "chai-spies": "^1.0.0",
+    "eslint": "^7.10.0",
+    "eslint-config-airbnb-base": "^14.2.0",
+    "eslint-plugin-import": "^2.22.1",
+    "mocha": "^8.1.3",
+    "npm-run-all": "^4.1.5"
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "homepage": "https://github.com/paralect/node-mongo#readme",
+  "keywords": [
+    "mongo",
+    "monk",
+    "paralect"
+  ],
+  "license": "MIT",
+  "main": "src/index.js",
+  "name": "@paralect/node-mongo",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/paralect/node-mongo.git"
+  },
+  "scripts": {
+    "test": "run-s test:*",
+    "test:eslint": "eslint ./",
+    "test:mocha": "NODE_ENV=test mocha --exit --recursive -c -R spec src/index.test.js"
+  },
+  "version": "2.1.1"
+}

package/.hive/src/lib/node-mongo/src/index.js

@@ -0,0 +1,64 @@
+import monk from 'monk';
+import _ from 'lodash';
+import MongoService from './mongo-service';
+import MongoQueryService from './mongo-query-service';
+
+const logger = global.logger || console;
+
+export const connect = (connectionString, settings) => {
+  const connectionSettings = _.defaults({}, settings, {
+    connectTimeoutMS: 20000,
+  });
+  const db = monk(connectionString, connectionSettings);
+
+  db.on("error-opening", (err) => {
+    logger.error(err, "Failed to connect to the mongodb on start");
+    throw err;
+  });
+
+  db.on("open", () => {
+    logger.info(`Connected to mongodb`);
+  });
+
+  db.on("close", (err) => {
+    if (err) {
+      logger.error(err, `Lost connection with mongodb: ${connectionString}`);
+    } else {
+      logger.warn(`Closed connection with mongodb: ${connectionString}`);
+    }
+  });
+
+  db.on("connected", (err) => {
+    if (err) {
+      logger.error(err);
+    } else {
+      logger.info(`Connected to mongodb`);
+    }
+  });
+
+  db.createService = (collectionName, options = {}) => {
+    const collection = db.get(collectionName, { castIds: false });
+
+    return new MongoService(collection, options);
+  };
+
+  db.setServiceMethod = (name, method) => {
+    MongoService.prototype[name] = function customMethod(...args) {
+      return method.apply(this, [this, ...args]);
+    };
+  };
+
+  db.createQueryService = (collectionName, options = {}) => {
+    const collection = db.get(collectionName, { castIds: false });
+
+    return new MongoQueryService(collection, options);
+  };
+
+  db.setQueryServiceMethod = (name, method) => {
+    MongoQueryService.prototype[name] = function customMethod(...args) {
+      return method.apply(this, [this, ...args]);
+    };
+  };
+
+  return db;
+};

package/.hive/src/lib/node-mongo/src/mongo-query-service.js

@@ -0,0 +1,78 @@
+import _ from 'lodash';
+import MongoServiceError from './mongo-service-error';
+
+class MongoQueryService {
+  constructor(collection, options = {}) {
+    this._collection = collection;
+    this._options = options;
+
+    this.name = collection.name;
+
+    this.aggregate = collection.aggregate;
+    this.count = collection.count;
+    this.distinct = collection.distinct;
+    this.geoHaystackSearch = collection.geoHaystackSearch;
+    this.indexes = collection.indexes;
+    this.mapReduce = collection.mapReduce;
+    this.stats = collection.stats;
+  }
+
+  async find(query = {}, opt = { perPage: 100, page: 0 }) {
+    const options = _.cloneDeep(opt);
+    const { page, perPage } = options;
+    const hasPaging = page > 0;
+    if (hasPaging) {
+      options.skip = (page - 1) * perPage;
+      options.limit = perPage;
+    }
+    delete options.perPage;
+    delete options.page;
+
+    const results = await this._collection.find(query, options);
+    if (!hasPaging) {
+      return {
+        results,
+      };
+    }
+
+    const countOptions = {};
+    if (options.session) countOptions.session = options.session;
+    const count = await this._collection.count(query, countOptions);
+    const pagesCount = Math.ceil(count / perPage) || 1;
+
+    return {
+      pagesCount,
+      results: results.map(doc => {
+        return _.omit(doc, opt.isIncludeSecureFields ? [] : this._options.secureFields || []);
+      }),
+      count,
+    };
+  }
+
+  async findOne(query = {}, options = {}) {
+    const { results } = await this.find(query, { limit: 2, ...options });
+
+    // if (results.length > 1) {
+    //   throw new MongoServiceError(
+    //     MongoServiceError.MORE_THAN_ONE,
+    //     `findOne: More than one document return for query ${JSON.stringify(
+    //       query
+    //     )}`
+    //   );
+    // }
+    let result = results[0] || null;
+
+    if (result && !options.isIncludeSecureFields) {
+      result = _.omit(result, this._options.secureFields || []);
+    }
+    
+    return result;
+  }
+
+  async exists(query, options = {}) {
+    const count = await this.count(query, { limit: 1, ...options });
+    return count > 0;
+  }
+}
+
+export default MongoQueryService;

package/.hive/src/lib/node-mongo/src/mongo-service-error.js

@@ -0,0 +1,15 @@
+class MongoServiceError extends Error {
+  constructor(code, message, error) {
+    super(message);
+    this.name = "MongoServiceError";
+    this.code = code;
+    this.error = error;
+  }
+}
+
+MongoServiceError.NOT_FOUND = "NOT_FOUND";
+MongoServiceError.MORE_THAN_ONE = "MORE_THAN_ONE";
+MongoServiceError.INVALID_SCHEMA = "INVALID_SCHEMA";
+MongoServiceError.INVALID_ARGUMENT = "INVALID_ARGUMENT";
+
+export default MongoServiceError;

package/.hive/src/lib/node-mongo/src/mongo-service.js

@@ -0,0 +1,303 @@
+import monk from 'monk';
+import { EventEmitter } from 'events';
+import _ from 'lodash';
+import MongoQueryService from './mongo-query-service';
+import MongoServiceError from './mongo-service-error';
+
+const defaultOptions = {
+  addCreatedOnField: true,
+  addUpdatedOnField: true,
+  useStringId: true,
+  validate: undefined,
+  emitter: undefined,
+  secureFields: ['verySecureField'],
+
+  onBeforeCreated: ({ docs }) => docs,
+};
+
+class MongoService extends MongoQueryService {
+  constructor(collection, options = {}) {
+    super(collection, options);
+    _.defaults(this._options, defaultOptions);
+
+    this._bus = this._options.emitter || new EventEmitter();
+
+    this.generateId = () => monk.id().toHexString();
+
+    this.atomic = {
+      bulkWrite: collection.bulkWrite,
+      createIndex: collection.createIndex,
+      drop: collection.drop,
+      dropIndex: collection.dropIndex,
+      dropIndexes: collection.dropIndexes,
+      findOneAndDelete: collection.findOneAndDelete,
+      findOneAndUpdate: collection.findOneAndUpdate,
+      insert: collection.insert,
+      remove: collection.remove,
+      update: collection.update,
+    };
+
+    collection.manager
+      .executeWhenOpened()
+      .then(async () => {
+        await collection.manager._db.command({ create: collection.name });
+      })
+      .catch((error) => {
+        // a collection already exists
+        if (error.code !== 48) {
+          throw error;
+        }
+      });
+  }
+
+  static _deepCompare(data, initialData, properties) {
+    let changed = false;
+
+    if (Array.isArray(properties)) {
+      changed =
+        _.find(properties, (prop) => {
+          const value = _.get(data, prop);
+          const initialValue = _.get(initialData, prop);
+
+          return !_.isEqual(value, initialValue);
+        }) !== undefined;
+    } else {
+      Object.keys(properties).forEach((prop) => {
+        if (changed) return;
+
+        const value = _.get(data, prop);
+        const initialValue = _.get(initialData, prop);
+
+        if (
+          _.isEqual(value, properties[prop]) &&
+          !_.isEqual(initialValue, properties[prop])
+        ) {
+          changed = true;
+        }
+      });
+    }
+
+    return changed;
+  }
+
+  async _validate(entity) {
+    if (this._options.validate) {
+      const { value, error } = await this._options.validate(entity);
+
+      if (error) {
+        console.log("Schema Error", error);
+
+        throw new MongoServiceError(
+          MongoServiceError.INVALID_SCHEMA,
+          `Document schema is invalid: ${JSON.stringify(error, null, 2)}`,
+          error
+        );
+      }
+
+      return value;
+    }
+
+    return entity;
+  }
+
+  emit(eventName, event) {
+    return this._bus.emit(`${this._collection.name}:${eventName}`, event);
+  }
+
+  once(eventName, handler) {
+    return this._bus.once(`${this._collection.name}:${eventName}`, handler);
+  }
+
+  on(eventName, handler) {
+    return this._bus.on(`${this._collection.name}:${eventName}`, handler);
+  }
+
+  onUpdated(fieldNames = [], handler = (e) => { }) {
+    return this.on(`${this._collection.name}:${eventName}`, (event) => {
+      const { doc, prevDoc } = event;
+
+      let isFieldChanged = false;
+
+      if (_.isArray(fieldNames)) {
+        _.forEach(fieldNames, (fieldName) => {
+          if (!_.isEqual(doc[fieldName], prevDoc[fieldName])) {
+            isFieldChanged = true;
+            return false; // break loop
+          }
+
+          return true;
+        });
+      } else if (_.isObject(fieldNames)) {
+        const fieldName = Object.keys(fieldNames)[0];
+
+        if (_.isEqual(_.get(doc, fieldName), fieldNames[fieldName]) && !_.isEqual(_.get(doc, fieldName), _.get(prevDoc, fieldName))) {
+          isFieldChanged = true;
+        }
+      }
+
+      if (isFieldChanged) handler(event);
+    });
+  }
+
+  async create(objs, options = {}) {
+    const entities = _.isArray(objs) ? objs : [objs];
+
+    let created = await Promise.all(
+      entities.map(async (doc) => {
+        const entity = _.cloneDeep(doc);
+
+        if (this._options.useStringId && !entity._id)
+          entity._id = this.generateId();
+        if (this._options.addCreatedOnField && !entity.createdOn) {
+          entity.createdOn = new Date().toISOString();
+        }
+        const validated = await this._validate(entity);
+
+        return validated;
+      })
+    );
+
+    created = await this._options.onBeforeCreated({ docs: created });
+
+    await this._collection.insert(created, options);
+
+    created.forEach((doc) => {
+      this._bus.emit(`${this._collection.name}:created`, {
+        doc,
+      });
+    });
+
+    created = created.map(doc => {
+      return _.omit(doc, options.isIncludeSecureFields ? [] : this._options.secureFields);
+    })
+
+    return created.length > 1 ? created : created[0];
+  }
+
+  async updateOne(query, updateFn, options = {}) {
+    if (!_.isFunction(updateFn)) {
+      throw new MongoServiceError(
+        MongoServiceError.INVALID_ARGUMENT,
+        `updateOne: second argument is invalid. Expected a function but got ${typeof updateFn}`
+      );
+    }
+
+    const findOptions = { isIncludeSecureFields: true };
+    if (options.session) findOptions.session = options.session;
+    const doc = await this.findOne(query, findOptions);
+    if (!doc) {
+      throw new MongoServiceError(
+        MongoServiceError.NOT_FOUND,
+        `updateOne: document not found. Query: ${JSON.stringify(query)}`
+      );
+    }
+
+    let entity = _.cloneDeep(doc);
+
+    if (this._options.addUpdatedOnField)
+      entity.updatedOn = new Date().toISOString();
+    entity = await updateFn(entity);
+    let updated = await this._validate(entity);
+
+    await this._collection.update(
+      { ...query, _id: doc._id },
+      { $set: updated },
+      options
+    );
+
+
+    this._bus.emit(`${this._collection.name}:updated`, {
+      doc: updated,
+      prevDoc: doc,
+    });
+
+    updated = _.omit(updated, options.isIncludeSecureFields ? [] : this._options.secureFields);
+
+    return updated;
+  }
+
+  async updateMany(query, updateFn, options = {}) {
+    if (!_.isFunction(updateFn)) {
+      throw new MongoServiceError(
+        MongoServiceError.INVALID_ARGUMENT,
+        `updateMany: second argument is invalid. Expected a function but got ${typeof updateFn}`
+      );
+    }
+
+    const findOptions = { isIncludeSecureFields: true };
+    if (options.session) findOptions.session = options.session;
+    const { results: docs } = await this.find(query, findOptions);
+    if (docs.length === 0) return [];
+
+    let updated = await Promise.all(
+      docs.map(async (doc) => {
+        let entity = _.cloneDeep(doc);
+
+        if (this._options.addUpdatedOnField)
+          entity.updatedOn = new Date().toISOString();
+        entity = await updateFn(entity);
+        const validated = await this._validate(entity);
+
+        return validated;
+      })
+    );
+
+    await Promise.all(
+      updated.map((doc) =>
+        this._collection.update(
+          { ...query, _id: doc._id },
+          { $set: doc },
+          options
+        )
+      )
+    );
+
+    updated.forEach((doc, index) => {
+      this._bus.emit(`${this._collection.name}:updated`, {
+        doc,
+        prevDoc: docs[index],
+      });
+    });
+
+    updated = updated.map(doc => _.omit(doc, options.isIncludeSecureFields ? [] : this._options.secureFields));
+
+    return updated;
+  }
+
+  async remove(query, options = {}) {
+    const findOptions = {};
+    if (options.session) findOptions.session = options.session;
+    const removed = await this.find(query, findOptions);
+    await this._collection.remove(query, options);
+
+    removed.results.forEach((doc) => {
+      this._bus.emit(`${this._collection.name}:removed`, {
+        doc,
+      });
+    });
+
+    return removed;
+  }
+
+  async performTransaction(transactionFn, options = {}) {
+    if (!_.isFunction(transactionFn)) {
+      throw new MongoServiceError(
+        MongoServiceError.INVALID_ARGUMENT,
+        `performTransaction: first argument is invalid. Expected a function but got ${typeof transactionFn}`
+      );
+    }
+
+    await this._collection.manager.executeWhenOpened();
+
+    const session = this._collection.manager._client.startSession(options);
+
+    try {
+      await session.withTransaction(transactionFn);
+    } catch (error) {
+      session.endSession();
+      throw error;
+    }
+  }
+}
+
+export default MongoService;

package/.hive/src/logger.js

@@ -0,0 +1,43 @@
+import winston from 'winston';
+import config from 'app-config';
+import fs from 'fs';
+
+const colorizer = winston.format.colorize();
+
+let appTransports = [];
+
+if (process.env.HIVE_SRC) {
+  if (fs.existsSync(`${process.env.HIVE_SRC}/app-config/logger.js`)) {
+    try {
+      appTransports = require(`${process.env.HIVE_SRC}/app-config/logger.js`).transports;
+    } catch (error) {
+      console.error('Error loading logger config', error);
+    }
+  }
+}
+
+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(), ...appTransports],
+  });
+
+  logger.debug("[logger] Configured console based logger");
+
+  return logger;
+};
+
+export default createConsoleLogger();

package/.hive/src/middlewares/allowNoAuth.js

@@ -0,0 +1,9 @@
+
+const middleware = async (ctx, next) => {
+  ctx.state.isSkipAuth = true;
+  return next();
+};
+
+middleware.runOrder = -1;
+
+export default middleware;

package/.hive/src/middlewares/attachUser.js

@@ -0,0 +1,41 @@
+import db from 'db';
+import config from 'app-config';
+
+const userService = db.services.users;
+const tokenService = 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();
+  }
+
+  if (!accessToken && config._hive.authHeaderName && ctx.headers[config._hive.authHeaderName]) {
+    accessToken = ctx.headers[config._hive.authHeaderName];
+  }
+
+  ctx.state.accessToken = accessToken;
+};
+
+export default 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 });
+
+    if (token.metadata) {
+      ctx.state.user.authMetadata = token.metadata;
+    }
+  }
+
+  await next();
+};

package/.hive/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();
+};
+
+export default storeTokenToState;

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

@@ -0,0 +1,33 @@
+import db from 'db';
+const userService = db.services.users;
+const tokenService = 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();
+};
+
+export default tryToAttachUser;

package/.hive/src/middlewares/isAuthorized.js

@@ -0,0 +1,18 @@
+import attachUser from './attachUser';
+
+export default async (ctx, next) => {
+  if (ctx.state.isSkipAuth) {
+    ctx.state.user = null;
+    return next();
+  }
+
+  await attachUser(ctx, async () => {
+    if (ctx.state.user) {
+      return next();
+    }
+
+    ctx.status = 401;
+    ctx.body = {};
+    return null;
+  });
+};