@modular-rest/server 1.6.6 → 1.8.0

package/README.md

@@ -6,6 +6,8 @@ a nodejs module based on KOAJS for developing Rest-APIs in a modular solution.
 this module has one method:
 - `createRest`: is the main functionality of the module.
 
+**Note**: active "javascript.implicitProjectConfig.checkJs": true in your vscode settings.
+
 ## Install 
 
 Install using [npm](https://www.npmjs.com/package/modular-rest):

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@modular-rest/server",
-  "version": "1.6.6",
+  "version": "1.8.0",
   "description": "a nodejs module based on KOAJS for developing Rest-APIs in a modular solution.",
   "main": "src/index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "generate:types": "tsc"
   },
+  "types": "./types/index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/navidshad/modular-rest.git"
@@ -35,5 +37,8 @@
     "mongoose": "^5.10.9",
     "nested-property": "^4.0.0"
   },
-  "devDependencies": {}
+  "devDependencies": {
+    "@types/koa": "^2.14.0",
+    "typescript": "^5.3.3"
+  }
 }

package/src/application.js

@@ -1,89 +1,53 @@
-let koa = require("koa");
+const koa = require("koa");
 const cors = require("@koa/cors");
 const koaBody = require("koa-body");
 const koaStatic = require("koa-static-server");
-var path = require("path");
-var Combination = require("./class/combinator");
-let DataProvider = require("./services/data_provider/service");
-let UserService = require("./services/user_manager/service");
+const path = require("path");
+const Combination = require("./class/combinator");
+const DataProvider = require("./services/data_provider/service");
+const UserService = require("./services/user_manager/service");
 
 let defaultServiceRoot = __dirname + "/services";
 
-// staticOptions = {
-//     /**
-//          * directory that is to be served
-//          */
-// rootDir?: string | undefined;
-// /**
-//  * optional rewrite path
-//  */
-// rootPath?: string | undefined;
-// /**
-//  * optional default file to serve if requested static is missing
-//  */
-// notFoundFile?: string | undefined;
-// /**
-//  * request access log to console
-//  */
-// log?: boolean | undefined;
-// /**
-//  * don't execute any downstream middleware. defaults to true
-//  */
-// last?: boolean | undefined;
-// /**
-//  * Browser cache max-age in milliseconds. defaults to 0
-//  */
-// maxage?: number | undefined;
-// /**
-//  * Allow transfer of hidden files. defaults to false
-//  */
-// hidden?: boolean | undefined;
-// /**
-//  * Try to serve the gzipped version of a file automatically when gzip is supported by a client and if the requested
-//  */
-// gzip?: boolean | undefined;
-// /**
-//  * Try to serve the brotli version of a file automatically when brotli is supported by a client and in the requested
-//  */
-// brotli?: boolean | undefined;
-// index?: string | undefined;
-// }
+/**
+ * @typedef {import('koa')} Koa
+ */
 
 /**
  * @param {{
- *   cors: any; // Options for @koa/cors middleware.
- *   modulesPath: string; // Root directory of your router.js/db.js files.
- *   static: {
- *      rootDir: string; // Root directory of your static files.
- *      rootPath: string; // Root path of your static files.
- *      notFoundFile: string; // Not found file.
- *      log: boolean; // Log requests to console.
- *      last: boolean; // Don't execute any downstream middleware.
- *      maxage: number; // Browser cache max-age in milliseconds.
- *      hidden: boolean; // Allow transfer of hidden files.
- *      gzip: boolean; // Try to serve the gzipped version of a file automatically when gzip is supported by a client and if the requested
- *      brotli: boolean; // Try to serve the brotli version of a file automatically when brotli is supported by a client and in the requested
- *      index: string; // Index file.
+ *   cors?: any; // Options for @koa/cors middleware.
+ *   modulesPath?: string; // Root directory of your router.js/db.js files.
+ *   staticPath?: {
+ *      rootDir?: string; // Root directory of your static files.
+ *      rootPath?: string; // Root path of your static files.
+ *      notFoundFile?: string; // Not found file.
+ *      log?: boolean; // Log requests to console.
+ *      last?: boolean; // Don't execute any downstream middleware.
+ *      maxage?: number; // Browser cache max-age in milliseconds.
+ *      hidden?: boolean; // Allow transfer of hidden files.
+ *      gzip?: boolean; // Try to serve the gzipped version of a file automatically when gzip is supported by a client and if the requested file exists.
+ *      brotli?: boolean; // Try to serve the brotli version of a file automatically when brotli is supported by a client and if the requested file exists.
+ *      index?: string; // Index file.
  *   };
- *   onBeforeInit: (koaApp) => void; // A callback called before initializing the Koa server.
- *   onAfterInit: (koaApp) => void; // A callback called after server initialization.
- *   port: number; // Server port.
- *   dontListen: boolean; // If true, the server will not run and will only return the Koa app object.
- *   mongo: {
+ *   onBeforeInit?: (koaApp:Koa) => void; // A callback called before initializing the Koa server.
+ *   onAfterInit?: (koaApp:Koa) => void; // A callback called after server initialization.
+ *   port?: number; // Server port.
+ *   dontListen?: boolean; // If true, the server will not run and will only return the Koa app object.
+ *   mongo?: {
  *     dbPrefix: string; // A prefix for your database name.
  *     mongoBaseAddress: string; // The address of your MongoDB server without any database specification.
- *     addressMap: string; // Specific addresses for each database.
+ *     addressMap?: string; // Specific addresses for each database.
  *   };
- *   keypair: {
+ *   keypair?: {
  *     private: string; // Private key for RSA authentication.
  *     public: string; // Public key for RSA authentication.
  *   };
- *   adminUser: {
+ *   adminUser?: {
  *     email: string; // Admin user email.
  *     password: string; // Admin user password.
  *   };
  *   verificationCodeGeneratorMethod: () => string; // A method to return a verification code when registering a new user.
- *   collectionDefinitions: CollectionDefinition[]; // An array of additional collection definitions.
+ *   collectionDefinitions?: CollectionDefinition[]; // An array of additional collection definitions.
  * }} options
  */
 module.exports = async function createRest(options) {
@@ -121,8 +85,8 @@ module.exports = async function createRest(options) {
   /**
    * Plug In KoaStatic
    */
-  if (options.static) {
-    app.use(koaStatic(options.static));
+  if (options.staticPath) {
+    app.use(koaStatic(options.staticPath));
   }
 
   /**

package/src/class/collection_definition.js

@@ -1,25 +1,33 @@
-module.exports = class CollectionDefinition {
-    /**
-     * This class helps to create a mongoose collection 
-     * associated with permissions and triggers .
-     * 
-     * @param {object} option
-     * @param {string} option.db database name
-     * @param {string} option.collection collection name
-     * @param {object} option.schema mongoose schema
-     * @param {array} option.permissions a list of Permission for this collection 
-     * @param {array} option.trigger a DatabaseTrigger
-     */
-    constructor({ db, collection, schema, permissions, trigger }) {
-        // string
-        this.database = db;
-        // string
-        this.collection = collection;
-        // schema object of mongoose
-        this.schema = schema;
-        // a list of Permission for this collection
-        this.permissions = permissions;
+/**
+ * @typedef {import('./security.js').Permission} Permission
+ * @typedef {import('./database_trigger.js')} DatabaseTrigger
+ */
 
-        this.trigger = trigger;
-    }
-}
+class CollectionDefinition {
+  /**
+   * This class helps to create a mongoose collection
+   * associated with permissions and triggers.
+   *
+   * @class
+   * @param {Object} option
+   * @param {string} option.db - Database name
+   * @param {string} option.collection - Collection name
+   * @param {Object} option.schema - Mongoose schema
+   * @param {Array<Permission>} option.permissions - A list of permissions for this collection
+   * @param {Array<DatabaseTrigger>=} option.trigger - A database trigger
+   */
+  constructor({ db, collection, schema, permissions, trigger }) {
+    // string
+    this.database = db;
+    // string
+    this.collection = collection;
+    // schema object of mongoose
+    this.schema = schema;
+    // a list of Permission for this collection
+    this.permissions = permissions;
+
+    this.trigger = trigger;
+  }
+}
+
+module.exports = CollectionDefinition;

package/src/class/combinator.js

@@ -1,90 +1,101 @@
-let Router = require('koa-router');
-let directory = require('./directory.js');
+let Router = require("koa-router");
+let directory = require("./directory.js");
 
 class Combinator {
+  async combineRoutesByFilePath(rootDirectory, app) {
+    // find route paths
+    let option = { name: "router", filter: [".js"] };
+    let routerPaths = await directory
+      .find(rootDirectory, option)
+      .then()
+      .catch((e) => {
+        console.log(e);
+      });
 
-    async combineRoutesByFilePath(rootDirectory, app) {
-        // find route paths
-        let option = { name: 'router', filter: ['.js'] }
-        let routerPaths = await directory.find(rootDirectory, option).then()
-            .catch(e => { console.log(e) });
+    // create and combine routes into the app
+    for (let i = 0; i < routerPaths.length; i++) {
+      let service = require(routerPaths[i]);
+      let name = service.name;
 
-        // create and combine routes into the app
-        for (let i = 0; i < routerPaths.length; i++) {
-            let service = require(routerPaths[i]);
-            let name = service.name;
+      var serviceRouter = new Router();
+      serviceRouter.use(`/${name}`, service.main.routes());
 
-
-            var serviceRouter = new Router();
-            serviceRouter.use(`/${name}`, service.main.routes());
-
-            app.use(serviceRouter.routes());
-        }
+      app.use(serviceRouter.routes());
     }
+  }
 
-    /**
-     * 
-     * @param {object} option
-     * @param {string} option.rootDirectory root directory of files
-     * @param {object} option.filename an object of {name, extension} 
-     * @param {string} option.filename.name name of file
-     * @param {string} option.filename.extension the extension of the file
-     * @param {boolean} option.combineWithRoot combine all file content and return theme as a object
-     * @param {boolean} option.convertToArray return file content as an array instead an object
-     */
-    async combineModulesByFilePath({
-        rootDirectory, filename, combineWithRoot, convertToArray
-    }) {
-        // find route paths
-        let rootObject_temp;
-        let option = { name: filename.name, filter: [filename.extension] }
-        let modulesPath = await directory.find(rootDirectory, option).then()
-            .catch(e => { console.log(e) });
+  /**
+   *
+   * @param {object} option
+   * @param {string} option.rootDirectory root directory of files
+   * @param {object} option.filename an object of {name, extension}
+   * @param {string} option.filename.name name of file
+   * @param {string} option.filename.extension the extension of the file
+   * @param {boolean} option.combineWithRoot combine all file content and return theme as a object
+   * @param {boolean} option.convertToArray return file content as an array instead an object
+   */
+  async combineModulesByFilePath({
+    rootDirectory,
+    filename,
+    combineWithRoot,
+    convertToArray,
+  }) {
+    // find route paths
+    let rootObject_temp;
+    let option = { name: filename.name, filter: [filename.extension] };
+    let modulesPath = await directory
+      .find(rootDirectory, option)
+      .then()
+      .catch((e) => {
+        console.log(e);
+      });
 
-        // create and combine routes into the app
-        for (let i = 0; i < modulesPath.length; i++) {
-            let moduleObject = require(modulesPath[i]);
+    // create and combine routes into the app
+    for (let i = 0; i < modulesPath.length; i++) {
+      let moduleObject = require(modulesPath[i]);
 
-            //act by otherOption
-            if (combineWithRoot) {
-                if(moduleObject.name)
-                    delete moduleObject.name;
+      //act by otherOption
+      if (combineWithRoot) {
+        if (moduleObject.name) delete moduleObject.name;
 
-                if(moduleObject.length) {
-                    if(!rootObject_temp) rootObject_temp = [];
-
-                    rootObject_temp = [...rootObject_temp, ...moduleObject];
-                }
-                else {
-                    rootObject_temp = this.extendObj(rootObject_temp, moduleObject);
-                }
-                // else if (typeof)
-            }
-            // default act
-            else {
-                let name = moduleObject.name;
-                rootObject_temp[name] = moduleObject;
-            }
-        }
+        if (moduleObject.length) {
+          if (!rootObject_temp) rootObject_temp = [];
 
-        // options 
-        // convertToArray
-        if (convertToArray) {
-            rootObject_temp = Object.values(rootObject_temp);
+          rootObject_temp = [...rootObject_temp, ...moduleObject];
+        } else {
+          rootObject_temp = this.extendObj(rootObject_temp, moduleObject);
         }
+        // else if (typeof)
+      }
+      // default act
+      else {
+        let name = moduleObject.name;
+        rootObject_temp[name] = moduleObject;
+      }
+    }
 
-        // set result to main rootObject
-        return rootObject_temp;
+    // options
+    // convertToArray
+    if (convertToArray) {
+      rootObject_temp = Object.values(rootObject_temp);
     }
 
-    extendObj(obj, src) {
-        for (var key in src) {
-            if (src.hasOwnProperty(key))
-                obj[key] = src[key];
-        }
-        return obj;
+    // set result to main rootObject
+    return rootObject_temp;
+  }
+
+  extendObj(obj, src) {
+    for (var key in src) {
+      if (src.hasOwnProperty(key)) obj[key] = src[key];
     }
+    return obj;
+  }
+
+  static get instance() {
+    return instance;
+  }
 }
 
-Combinator.instance = new Combinator();
+const instance = new Combinator();
+
 module.exports = Combinator.instance;

package/src/class/database_trigger.js

@@ -1,15 +1,19 @@
+/**
+ * `DatabaseTrigger` is a class that defines a callback to be called on a specific database transaction.
+ *
+ * @class
+ */
 class DatabaseTrigger {
-    /**
-     * Is a definition for a callback being called on 
-     * a specific database transaction.
-     * 
-     * @param {string} operation Operation name
-     * @param {function} callback trigger callback
-     */
-    constructor(operation, callback = (query, queryResult) => { }) {
-        this.operation = operation;
-        this.callback = callback;
-    }
+  /**
+   * Creates a new instance of `DatabaseTrigger`.
+   *
+   * @param {'find' | 'find-one' | 'count' | 'update-one' | 'insert-one' | 'remove-one' | 'aggregate'} operation - The operation to be triggered. Supported operations are:
+   * @param {function(query, queryResult)} callback - The callback to be called when the operation is executed.
+   */
+  constructor(operation, callback = (query, queryResult) => {}) {
+    this.operation = operation;
+    this.callback = callback;
+  }
 }
 
-module.exports = DatabaseTrigger;
+module.exports = DatabaseTrigger;

package/src/class/security.js

@@ -1,44 +1,126 @@
+/**
+ * Class representing an access definition.
+ */
 class AccessDefinition {
-    constructor({ database, collection, permissionList }) {
-        this.database = database;
-        this.collection = collection;
-        this.permissionList = permissionList;
-    }
+  /**
+   * Create an access definition.
+   * @param {Object} options - The options for the access definition.
+   * @param {string} options.database - The name of the database.
+   * @param {string} options.collection - The name of the collection.
+   * @param {Array.<Permission>} options.permissionList - The list of permissions.
+   */
+  constructor({ database, collection, permissionList }) {
+    this.database = database;
+    this.collection = collection;
+    this.permissionList = permissionList;
+  }
 }
 
+/**
+ * @typedef {('god_access'|'user_access'|'upload_file_access'|'remove_file_access'|'anonymous_access')} PermissionType
+ */
+
+/**
+ * Class representing a permission.
+ */
 class Permission {
-    constructor({ type, read = false, write = false, onlyOwnData = false }) {
-        this.type = type;
-        this.read = read;
-        this.write = write;
-        /**
-         * If true users can perform CRUD on documents that they created already.
-         */
-        this.onlyOwnData = onlyOwnData;
-    }
+  /**
+   * Create a permission.
+   * @param {Object} options - The options for the permission.
+   * @param {PermissionType} options.type - The type of the permission.
+   * @param {boolean} [options.read=false] - The read access of the permission.
+   * @param {boolean} [options.write=false] - The write access of the permission.
+   * @param {boolean} [options.onlyOwnData=false] - If true, users can perform CRUD on documents that they created already.
+   * @param {string} [options.ownerIdField='refId'] - The name of the field that contains the owner's id of the document.
+   */
+  constructor({
+    type,
+    read = false,
+    write = false,
+    onlyOwnData = false,
+    ownerIdField = "refId",
+  }) {
+    this.type = type;
+    this.read = read;
+    this.write = write;
+    this.onlyOwnData = onlyOwnData;
+    this.ownerIdField = ownerIdField;
+  }
 }
 
+/**
+ * Class representing different types of permissions.
+ * Each static getter returns a string that represents a specific type of permission.
+ */
 class PermissionTypes {
-    constructor() {
-        this.god_access = 'god_access';
-        this.user_access = 'user_access';
-        this.upload_file_access = 'upload_file_access';
-        this.remove_file_access = 'remove_file_access';
-        this.anonymous_access = 'anonymous_access';
-    }
-
-    static get god_access() { return 'god_access' };
-    static get user_access() { return 'user_access' };
-    static get upload_file_access() { return 'upload_file_access' };
-    static get remove_file_access() { return 'remove_file_access' };
-    static get anonymous_access() { return 'anonymous_access' };
+  /**
+   * Create permission types.
+   * Each property represents a specific type of permission.
+   */
+  constructor() {
+    this.god_access = "god_access"; // Represents god access permission type
+    this.user_access = "user_access"; // Represents user access permission type
+    this.upload_file_access = "upload_file_access"; // Represents upload file access permission type
+    this.remove_file_access = "remove_file_access"; // Represents remove file access permission type
+    this.anonymous_access = "anonymous_access"; // Represents anonymous access permission type
+  }
+
+  /**
+   * Get the string representing god access permission type.
+   * @return {string} The god access permission type.
+   */
+  static get god_access() {
+    return "god_access";
+  }
+
+  /**
+   * Get the string representing user access permission type.
+   * @return {string} The user access permission type.
+   */
+  static get user_access() {
+    return "user_access";
+  }
+
+  /**
+   * Get the string representing upload file access permission type.
+   * @return {string} The upload file access permission type.
+   */
+  static get upload_file_access() {
+    return "upload_file_access";
+  }
+
+  /**
+   * Get the string representing remove file access permission type.
+   * @return {string} The remove file access permission type.
+   */
+  static get remove_file_access() {
+    return "remove_file_access";
+  }
+
+  /**
+   * Get the string representing anonymous access permission type.
+   * @return {string} The anonymous access permission type.
+   */
+  static get anonymous_access() {
+    return "anonymous_access";
+  }
 }
 
+/**
+ * Class representing access types.
+ */
 class AccessTypes {
-    static get read() { return 'read' };
-    static get write() { return 'write' };
+  static get read() {
+    return "read";
+  }
+  static get write() {
+    return "write";
+  }
 }
 
 module.exports = {
-    AccessDefinition, Permission, PermissionTypes, AccessTypes
-}
+  AccessDefinition,
+  Permission,
+  PermissionTypes,
+  AccessTypes,
+};

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,47 +14,29 @@ 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
-  //
+  // Route 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
-   */
+  // Service utilities
   getCollection,
 
-  //
-  // Base class
-  //
+  // Database
   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,195 @@
-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;
+
+  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;
+  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;
+  const permissionList = _getPermissionList(db, collection, operationType);
+
+  permissionList.forEach((permission) => {
+    let permissionType = permission.type;
+
+    if (permission.onlyOwnData == true) {
+      const userId = user.id;
+
+      try {
+        if (
+          queryOrDoc[permission.ownerIdField].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 key;
+  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;
+  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 +197,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,
+};

package/src/services/user_manager/service.js

@@ -373,8 +373,12 @@ class UserManager {
     let authM = DataProvider.getCollection("cms", "auth");
     return authM.updateOne(query, update).exec().then();
   }
+
+  static get instance() {
+    return instance;
+  }
 }
 
-UserManager.instance = new UserManager();
+const instance = new UserManager();
 module.exports.name = "userManager";
 module.exports.main = UserManager.instance;

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "include": ["**/*.js"],
+  "compilerOptions": {
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "allowJs": true,
+    "outDir": "./types",
+    "checkJs": false
+  }
+}