@paralect/hive 0.1.50-alpha.2 → 0.1.50

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

@@ -1,74 +0,0 @@
-{
-  "_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/starter/src/lib/node-mongo/src/index.js

@@ -1,64 +0,0 @@
-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/starter/src/lib/node-mongo/src/mongo-query-service.js

@@ -1,78 +0,0 @@
-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/starter/src/lib/node-mongo/src/mongo-service-error.js

@@ -1,15 +0,0 @@
-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/starter/src/lib/node-mongo/src/mongo-service.js

@@ -1,303 +0,0 @@
-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/starter/src/middlewares/attachUser.js

@@ -1,41 +0,0 @@
-import db from '#hive/db';
-import config from '#hive/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/starter/src/middlewares/global/extractUserTokens.js

@@ -1,15 +0,0 @@
-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/starter/src/middlewares/global/tryToAttachUser.js

@@ -1,33 +0,0 @@
-import db from '#hive/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/starter/src/middlewares/isAuthorized.js

@@ -1,18 +0,0 @@
-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;
-  });
-};

package/starter/src/middlewares/shouldExist.js

@@ -1,37 +0,0 @@
-import db from '#hive/db';
-
-function singularize(word) {
-  const endings = {
-    ves: 'fe',
-    ies: 'y',
-    i: 'us',
-    zes: 'ze',
-    ses: 's',
-    es: 'e',
-    s: '',
-  };
-  return word.replace(
-    new RegExp(`(${Object.keys(endings).join('|')})$`),
-    (r) => endings[r]
-  );
-}
-
-export default (
-  resourceName,
-  {
-    criteria = (ctx) => ({ _id: ctx.params[`${singularize(resourceName)}Id`] }),
-    ctxName = resourceName,
-  } = {}
-) => {
-  return async (ctx, next) => {
-    const doc = await db.services[resourceName].findOne(criteria(ctx));
-    ctx.state[ctxName] = doc;
-    ctx.state[singularize(resourceName)] = doc;
-
-    if (!doc) {
-      ctx.throw(404, { message: `${resourceName} not found` });
-    } else {
-      await next();
-    }
-  };
-};

package/starter/src/middlewares/shouldNotExist.js

@@ -1,19 +0,0 @@
-import _ from 'lodash';
-import db from '#hive/db';
-
-export default (
-  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();
-    }
-  };
-};