@modular-rest/server 1.6.5 → 1.7.0

package/src/class/trigger_operator.js

@@ -1,38 +1,42 @@
 class TriggerOperator {
-    constructor() {
-        this.triggers = [];
-    }
+  constructor() {
+    this.triggers = [];
+  }
 
-    /**
-     * add a collection trigger
-     * @param {object} trigger DatabaseTrigger object
-     */
-    addTrigger(trigger) {
-        this.triggers.push(trigger);
-    }
+  /**
+   * add a collection trigger
+   * @param {object} trigger DatabaseTrigger object
+   */
+  addTrigger(trigger) {
+    this.triggers.push(trigger);
+  }
 
-    /**
-     * Call a trigger
-     * @param {string} operation operation name
-     * @param {string} database database name
-     * @param {string} collection collection name
-     * @param {string} data 
-     */
-    call(operation, database, collection, data) {
-        let result;
+  /**
+   * Call a trigger
+   * @param {string} operation operation name
+   * @param {string} database database name
+   * @param {string} collection collection name
+   * @param {string} data
+   */
+  call(operation, database, collection, data) {
+    let result;
 
-        this.triggers.forEach(trigger => {
-            if (
-                operation == trigger.operation &&
-                database == trigger.database &&
-                collection == trigger.collection
-            )
-                result = trigger.callback(data.input, data.output);
-        });
+    this.triggers.forEach((trigger) => {
+      if (
+        operation == trigger.operation &&
+        database == trigger.database &&
+        collection == trigger.collection
+      )
+        result = trigger.callback(data.input, data.output);
+    });
 
-        return result;
-    }
+    return result;
+  }
+
+  static get instance() {
+    return instance;
+  }
 }
 
-TriggerOperator.instance = new TriggerOperator();
-module.exports = TriggerOperator.instance;
+const instance = new TriggerOperator();
+module.exports = TriggerOperator.instance;

package/src/index.js

@@ -14,44 +14,21 @@ const CollectionDefinition = require("./class/collection_definition");
 const Schemas = require("./class/db_schemas");
 const DatabaseTrigger = require("./class/database_trigger");
 const SecurityClass = require("./class/security");
-
 const middleware = require("./middlewares");
+const userManager = require("./services/user_manager/service");
 
 module.exports = {
   createRest,
-
-  //
-  // Utilities
-  //
   reply,
   TypeCasters,
-
-  /**
-   * @type {import('./class/paginator').create}
-   */
   paginator,
-
-  /**
-   * @type {import('./class/validator')}
-   */
   validator,
-
-  /**
-   * @type {import('./services/data_provider/service').getCollection}
-   * @return {import('mongoose').Model} Mongoose model https://mongoosejs.com/docs/api/model.html
-   */
   getCollection,
-
-  //
-  // Base class
-  //
   CollectionDefinition,
   Schemas,
   Schema,
   DatabaseTrigger,
-
   ...SecurityClass,
-
-  // Middlewares
   middleware,
+  userManager: userManager.main,
 };

package/src/middlewares.js

@@ -1,4 +1,13 @@
+/**
+ * Validator module
+ * @module class/validator
+ */
 let validateObject = require("./class/validator");
+
+/**
+ * User manager service
+ * @module services/user_manager/service
+ */
 const userManager = require("./services/user_manager/service");
 
 /**
@@ -9,7 +18,7 @@ const userManager = require("./services/user_manager/service");
  * @param {Function} next - Koa next function
  * @returns {Promise<void>}
  */
-module.exports.auth = async (ctx, next) => {
+async function auth(ctx, next) {
   let headers = ctx.header;
   let headersValidated = validateObject(headers, "authorization");
 
@@ -27,4 +36,8 @@ module.exports.auth = async (ctx, next) => {
       console.log(err);
       ctx.throw(err.status || 412, err.message);
     });
+}
+
+module.exports = {
+  auth,
 };

package/src/services/data_provider/service.js

@@ -1,196 +1,193 @@
-let name = 'dataProvider';
-const colog = require('colog');
-let {
-    AccessTypes,
-    AccessDefinition
-} = require('../../class/security');
+let name = "dataProvider";
+const colog = require("colog");
+let { AccessTypes, AccessDefinition } = require("../../class/security");
 
-const Mongoose = require('mongoose');
-Mongoose.set('useCreateIndex', true);
+const Mongoose = require("mongoose");
+Mongoose.set("useCreateIndex", true);
 
 let connections = {};
 let collections = {};
 let permissionDefinitions = {};
 
-let triggers = require('../../class/trigger_operator');
-let TypeCasters = require('./typeCasters');
+let triggers = require("../../class/trigger_operator");
+let TypeCasters = require("./typeCasters");
 
 /**
- * 
+ *
  * @param {string} dbName database name
  * @param {array} CollectionDefinitionList an array of CollectionDefinition instance
  * @param {object} mongoOption
  * @param {string} mongoOption.dbPrefix
  * @param {string} mongoOption.mongoBaseAddress
  */
-function connectToDatabaseByCollectionDefinitionList(dbName, collectionDefinitionList = [], mongoOption) {
-
-    return new Promise((done, reject) => {
-        // Create db connection
-        //
-        const fullDbName = (mongoOption.dbPrefix || '') + dbName
-        const connectionString = mongoOption.mongoBaseAddress + '/' + fullDbName;
-
-        colog.info(`- Connecting to database ${connectionString}`)
-
-        let connection = Mongoose.createConnection(connectionString, {
-            ...mongoOption,
-            useUnifiedTopology: true,
-            useNewUrlParser: true,
-        });
-
-        // Store connection
-        connections[dbName] = connection;
-
-        // add db models from schemas
-        collectionDefinitionList.forEach(collectionDefinition => {
-
-            let collection = collectionDefinition.collection;
-            let schema = collectionDefinition.schema;
-
-            if (collections[dbName] == undefined)
-                collections[dbName] = {};
-
-            if (permissionDefinitions[dbName] == undefined)
-                permissionDefinitions[dbName] = {};
-
-            // create model from schema
-            // and store in on global collection object
-            let model = connection.model(collection, schema);
-            collections[dbName][collection] = model
-
-            // define Access Definition from component permissions
-            // and store it on global access definition object
-            permissionDefinitions[dbName][collection] = new AccessDefinition({
-                database: dbName,
-                collection: collection,
-                permissionList: collectionDefinition.permissions
-            });
-
-            // add trigger
-            if (collectionDefinition.trigger != undefined) {
-                triggers.addTrigger(collectionDefinition.trigger);
-            }
-
-        })
-
-        connection.on('connected', () => {
-            colog.success(`- ${fullDbName} database has been connected`)
-            done()
-        });
-    })
+function connectToDatabaseByCollectionDefinitionList(
+  dbName,
+  collectionDefinitionList = [],
+  mongoOption
+) {
+  return new Promise((done, reject) => {
+    // Create db connection
+    //
+    const fullDbName = (mongoOption.dbPrefix || "") + dbName;
+    const connectionString = mongoOption.mongoBaseAddress + "/" + fullDbName;
+
+    colog.info(`- Connecting to database ${connectionString}`);
+
+    let connection = Mongoose.createConnection(connectionString, {
+      ...mongoOption,
+      useUnifiedTopology: true,
+      useNewUrlParser: true,
+    });
+
+    // Store connection
+    connections[dbName] = connection;
+
+    // add db models from schemas
+    collectionDefinitionList.forEach((collectionDefinition) => {
+      let collection = collectionDefinition.collection;
+      let schema = collectionDefinition.schema;
+
+      if (collections[dbName] == undefined) collections[dbName] = {};
+
+      if (permissionDefinitions[dbName] == undefined)
+        permissionDefinitions[dbName] = {};
+
+      // create model from schema
+      // and store in on global collection object
+      let model = connection.model(collection, schema);
+      collections[dbName][collection] = model;
+
+      // define Access Definition from component permissions
+      // and store it on global access definition object
+      permissionDefinitions[dbName][collection] = new AccessDefinition({
+        database: dbName,
+        collection: collection,
+        permissionList: collectionDefinition.permissions,
+      });
+
+      // add trigger
+      if (collectionDefinition.trigger != undefined) {
+        triggers.addTrigger(collectionDefinition.trigger);
+      }
+    });
+
+    connection.on("connected", () => {
+      colog.success(`- ${fullDbName} database has been connected`);
+      done();
+    });
+  });
 }
 
 /**
- * 
+ *
  * @param {object} option
  * @param {array} option.list an array of CollectionDefinition instance
  * @param {object} option.mongoOption
  * @param {string} option.mongoOption.dbPrefix
  * @param {string} option.mongoOption.mongoBaseAddress
  */
-async function addCollectionDefinitionByList({
-    list,
-    mongoOption
-}) {
-    let clusteredByDBName = {};
-
-    // cluster list by their database name.
-    list.forEach(collectionDefinition => {
-        let database = collectionDefinition.database;
-        if (!clusteredByDBName[database]) clusteredByDBName[database] = [];
-        clusteredByDBName[database].push(collectionDefinition);
-    })
-
-    // connect to databases
-    for (const dbName in clusteredByDBName) {
-        if (clusteredByDBName.hasOwnProperty(dbName)) {
-            const collectionDefinitionList = clusteredByDBName[dbName];
-            await connectToDatabaseByCollectionDefinitionList(dbName, collectionDefinitionList, mongoOption);
-        }
+async function addCollectionDefinitionByList({ list, mongoOption }) {
+  let clusteredByDBName = {};
+
+  // cluster list by their database name.
+  list.forEach((collectionDefinition) => {
+    let database = collectionDefinition.database;
+    if (!clusteredByDBName[database]) clusteredByDBName[database] = [];
+    clusteredByDBName[database].push(collectionDefinition);
+  });
+
+  // connect to databases
+  for (const dbName in clusteredByDBName) {
+    if (clusteredByDBName.hasOwnProperty(dbName)) {
+      const collectionDefinitionList = clusteredByDBName[dbName];
+      await connectToDatabaseByCollectionDefinitionList(
+        dbName,
+        collectionDefinitionList,
+        mongoOption
+      );
     }
+  }
 }
 
+/**
+ * Get a collection from a database.
+ * @param {string} db - The database name.
+ * @param {string} collection - The collection name.
+ * @returns {import('mongoose').Model} The found collection.
+ */
 function getCollection(db, collection) {
-    let fountCollection;
+  let fountCollection;
 
-    if (collections.hasOwnProperty(db)) {
-        if (collections[db].hasOwnProperty(collection))
-            fountCollection = collections[db][collection];
-    }
+  if (collections.hasOwnProperty(db)) {
+    if (collections[db].hasOwnProperty(collection))
+      fountCollection = collections[db][collection];
+  }
 
-    return fountCollection;
+  return fountCollection;
 }
 
 function _getPermissionList(db, collection, operationType) {
-    let permissionList = [];
-    let permissionDefinition;
-
-    if (!permissionDefinitions.hasOwnProperty(db))
-        return permissionList;
-
-    permissionDefinition = permissionDefinitions[db][collection];
-
-    permissionDefinition.permissionList.forEach(permission => {
-        if (permission.onlyOwnData == true) {
-            permissionList.push(permission);
-        } else if (operationType == AccessTypes.read &&
-            permission.read == true) {
-            permissionList.push(permission);
-        } else if (operationType == AccessTypes.write &&
-            permission.write == true) {
-            permissionList.push(permission);
-        }
-    });
+  let permissionList = [];
+  let permissionDefinition;
+
+  if (!permissionDefinitions.hasOwnProperty(db)) return permissionList;
 
-    return permissionList;
+  permissionDefinition = permissionDefinitions[db][collection];
+
+  permissionDefinition.permissionList.forEach((permission) => {
+    if (permission.onlyOwnData == true) {
+      permissionList.push(permission);
+    } else if (operationType == AccessTypes.read && permission.read == true) {
+      permissionList.push(permission);
+    } else if (operationType == AccessTypes.write && permission.write == true) {
+      permissionList.push(permission);
+    }
+  });
+
+  return permissionList;
 }
 
 function checkAccess(db, collection, operationType, queryOrDoc, user) {
-    let key = false;
-    let permissionList = _getPermissionList(db, collection, operationType);
-
-    permissionList.forEach(permission => {
-        let permissionType = permission.type;
-
-        if (permission.onlyOwnData == true) {
-            let owner = queryOrDoc.owner;
-            let userId = user.id;
-
-            try {
-                if (owner.toString() == userId.toString())
-                    key = true;
-            } catch (error) {
-                key = false;
-            }
-        } else if (operationType == AccessTypes.read) {
-            if (permission.read &&
-                user.permission[permissionType] == true)
-                key = true;
-        } else if (operationType == AccessTypes.write) {
-
-            if (permission.write &&
-                user.permission[permissionType] == true)
-                key = true;
-        }
-    });
+  let key = false;
+  let permissionList = _getPermissionList(db, collection, operationType);
 
-    return key;
-}
+  permissionList.forEach((permission) => {
+    let permissionType = permission.type;
 
-function getAsID(strId) {
-    let id;
-    try {
-        id = Mongoose.Types.ObjectId(strId);
-    } catch (e) {
-        console.log('strId did not cast objectId', e);
+    if (permission.onlyOwnData == true) {
+      let owner = queryOrDoc.owner;
+      let userId = user.id;
+
+      try {
+        if (owner.toString() == userId.toString()) key = true;
+      } catch (error) {
+        key = false;
+      }
+    } else if (operationType == AccessTypes.read) {
+      if (permission.read && user.permission[permissionType] == true)
+        key = true;
+    } else if (operationType == AccessTypes.write) {
+      if (permission.write && user.permission[permissionType] == true)
+        key = true;
     }
+  });
 
-    return id;
+  return key;
+}
+
+function getAsID(strId) {
+  let id;
+  try {
+    id = Mongoose.Types.ObjectId(strId);
+  } catch (e) {
+    console.log("strId did not cast objectId", e);
+  }
+
+  return id;
 }
 
 function performPopulateToQueryObject(queryObj, popArr = []) {
-    /*
+  /*
       https://mongoosejs.com/docs/populate.html
       popArr must be contains this objects
       { 
@@ -198,36 +195,35 @@ function performPopulateToQueryObject(queryObj, popArr = []) {
         select: 'name -_id',
       }
     */
-    popArr.forEach(pop => queryObj.populate(pop));
-    return queryObj;
+  popArr.forEach((pop) => queryObj.populate(pop));
+  return queryObj;
 }
 
 function performAdditionalOptionsToQueryObject(queryObj, options) {
-    /**
-     * https://mongoosejs.com/docs/api/query.html#query_Query-sort
-     * 
-     * Options must be contain a method name and an argument of above methods.
-     * {
-     *  sort: '-_id',
-     *  limit: 10,
-     * }
-     */
-    Object.keys(options).forEach(method => {
-        queryObj = queryObj[method](options[method]);
-    })
-
-    return queryObj;
+  /**
+   * https://mongoosejs.com/docs/api/query.html#query_Query-sort
+   *
+   * Options must be contain a method name and an argument of above methods.
+   * {
+   *  sort: '-_id',
+   *  limit: 10,
+   * }
+   */
+  Object.keys(options).forEach((method) => {
+    queryObj = queryObj[method](options[method]);
+  });
+
+  return queryObj;
 }
 
-
 module.exports = {
-    name,
-    getCollection,
-    addCollectionDefinitionByList,
-    checkAccess,
-    getAsID,
-    performPopulateToQueryObject,
-    performAdditionalOptionsToQueryObject,
-    triggers,
-    TypeCasters,
-}
+  name,
+  getCollection,
+  addCollectionDefinitionByList,
+  checkAccess,
+  getAsID,
+  performPopulateToQueryObject,
+  performAdditionalOptionsToQueryObject,
+  triggers,
+  TypeCasters,
+};