hola-server 0.3.3 → 0.3.6

package/core/date.js

@@ -1,54 +1,55 @@
-const date_format = require('dateformat');
+const date_format = require("dateformat");
+// import date_format from "dateformat";
 
 /**
  * Format the date object time part using HH:MM
- * @param {date object to be formatted} date 
- * @returns 
+ * @param {date object to be formatted} date
+ * @returns
  */
 const format_time = (date) => {
-    return date_format(date, "HH:MM");
+  return date_format(date, "HH:MM");
 };
 
 /**
  * Format date object using mm/dd
- * @param {date object to be formatted} date 
- * @returns 
+ * @param {date object to be formatted} date
+ * @returns
  */
-const simple_date = date => {
-    return date_format(date, "mm/dd");
-}
+const simple_date = (date) => {
+  return date_format(date, "mm/dd");
+};
 
 /**
  * Format date obj using yyyymmdd
- * @param {date object to be formatted} date 
- * @returns 
+ * @param {date object to be formatted} date
+ * @returns
  */
-const format_date = date => {
-    return date_format(date, "yyyymmdd");
-}
+const format_date = (date) => {
+  return date_format(date, "yyyymmdd");
+};
 
 /**
  * Format data obj using yyyymmdd hh:mm:ss
- * @param {date object to be formatted} date 
- * @returns 
+ * @param {date object to be formatted} date
+ * @returns
  */
-const format_date_time = date => {
-    return date_format(date, "yyyymmdd HH:MM:ss");
-}
+const format_date_time = (date) => {
+  return date_format(date, "yyyymmdd HH:MM:ss");
+};
 
 /**
  * Parse the date object using yyyymmdd format
- * @param {date str to be parsed} date 
- * @returns 
+ * @param {date str to be parsed} date
+ * @returns
  */
 const parse_date = (date) => {
-    const year = parseInt(date.substr(0, 4));
-    const month = parseInt(date.substr(4, 2));
-    const day = parseInt(date.substr(6, 2));
-    const dateObj = new Date();
-    dateObj.setFullYear(year, month - 1, day);
-    dateObj.setHours(0, 0, 0, 0);
-    return dateObj;
-}
+  const year = parseInt(date.substr(0, 4));
+  const month = parseInt(date.substr(4, 2));
+  const day = parseInt(date.substr(6, 2));
+  const dateObj = new Date();
+  dateObj.setFullYear(year, month - 1, day);
+  dateObj.setHours(0, 0, 0, 0);
+  return dateObj;
+};
 
-module.exports = { simple_date, format_date, format_time, format_date_time, parse_date }
+module.exports = { simple_date, format_date, format_time, format_date_time, parse_date };

package/core/meta.js

@@ -166,6 +166,7 @@ class EntityMeta {
         this.file_fields = meta.fields.filter(f => f.type === 'file');
         this.upload_fields = this.file_fields && this.file_fields.length > 0 ? this.file_fields.map(f => ({ name: f.name, maxCount: f.max ? f.max : 1 })) : [];
 
+        set_callback(this, "after_read", meta.after_read);
         set_callback(this, "before_create", meta.before_create);
         set_callback(this, "before_update", meta.before_update);
         set_callback(this, "before_delete", meta.before_delete);

package/db/db.js

@@ -1,8 +1,8 @@
-const mongoist = require('mongoist');
+const mongoist = require("mongoist");
 
-const { get_settings } = require('../setting');
-const { get_context_value } = require('../http/context');
-const { format_date_time } = require('../core/date');
+const { get_settings } = require("../setting");
+const { get_context_value } = require("../http/context");
+const { format_date_time } = require("../core/date");
 
 const LOG_LEVEL_DEBUG = 0;
 const LOG_LEVEL_INFO = 1;
@@ -14,349 +14,347 @@ const LOG_ENTITY = "entity";
 const LOG_SYSTEM = "system";
 
 const get_session_userid = () => {
-    const req = get_context_value("req");
-    return req && req.session && req.session.user ? req.session.user.id : '';
-}
+  const req = get_context_value("req");
+  return req && req.session && req.session.user ? req.session.user.id : "";
+};
 
 const log_msg = (category, level, msg) => {
-    const time = format_date_time(new Date());
-    const db = get_db();
-    const { col_log } = get_settings().log;
+  const time = format_date_time(new Date());
+  const db = get_db();
+  const { col_log } = get_settings().log;
 
-    const req = get_context_value("req");
-    const path = req ? req.originalUrl : '';
-    const user = req && req.session && req.session.user ? req.session.user.id : '';
+  const req = get_context_value("req");
+  const path = req ? req.originalUrl : "";
+  const user = req && req.session && req.session.user ? req.session.user.id : "";
 
-    db.create(col_log, { time: time, category: category, level: level, msg: msg, user: user, path: path }).then(() => { });
-}
+  db.create(col_log, { time: time, category: category, level: level, msg: msg, user: user, path: path }).then(() => {});
+};
 
 const is_log_debug = () => {
-    const { save_db, log_level } = get_settings().log;
-    return save_db && log_level <= LOG_LEVEL_DEBUG;
-}
+  const { save_db, log_level } = get_settings().log;
+  return save_db && log_level <= LOG_LEVEL_DEBUG;
+};
 
 const is_log_info = () => {
-    const { save_db, log_level } = get_settings().log;
-    return save_db && log_level <= LOG_LEVEL_INFO;
-}
+  const { save_db, log_level } = get_settings().log;
+  return save_db && log_level <= LOG_LEVEL_INFO;
+};
 
 const is_log_warn = () => {
-    const { save_db, log_level } = get_settings().log;
-    return save_db && log_level <= LOG_LEVEL_WARN;
-}
+  const { save_db, log_level } = get_settings().log;
+  return save_db && log_level <= LOG_LEVEL_WARN;
+};
 
 const is_log_error = () => {
-    const { save_db, log_level } = get_settings().log;
-    return save_db && log_level <= LOG_LEVEL_ERROR;
-}
+  const { save_db, log_level } = get_settings().log;
+  return save_db && log_level <= LOG_LEVEL_ERROR;
+};
 
 const log_debug = (category, msg) => {
-    if (is_log_debug()) {
-        log_msg(category, LOG_LEVEL_DEBUG, msg);
-    }
-}
+  if (is_log_debug()) {
+    log_msg(category, LOG_LEVEL_DEBUG, msg);
+  }
+};
 
 const log_info = (category, msg) => {
-    if (is_log_info()) {
-        log_msg(category, LOG_LEVEL_INFO, msg);
-    }
-}
+  if (is_log_info()) {
+    log_msg(category, LOG_LEVEL_INFO, msg);
+  }
+};
 
 const log_warn = (category, msg) => {
-    if (is_log_warn()) {
-        log_msg(category, LOG_LEVEL_WARN, msg);
-    }
-}
+  if (is_log_warn()) {
+    log_msg(category, LOG_LEVEL_WARN, msg);
+  }
+};
 
 const log_error = (category, msg) => {
-    if (is_log_error()) {
-        log_msg(category, LOG_LEVEL_ERROR, msg);
-    }
-}
+  if (is_log_error()) {
+    log_msg(category, LOG_LEVEL_ERROR, msg);
+  }
+};
 
 /**
  * Construct mongodb ObjectId
- * @param {string value of the id} id 
- * @returns 
+ * @param {string value of the id} id
+ * @returns
  */
 const oid = (id) => {
-    return mongoist.ObjectId(id);
+  return mongoist.ObjectId(id);
 };
 
 /**
  * Construct objectId query object
- * @param {string value of the id} id 
+ * @param {string value of the id} id
  * @returns id query if id is valid otherwise return null
  */
 const oid_query = (id) => {
-    try {
-        return { _id: oid(id) };
-    } catch (e) {
-        return null;
-    }
+  try {
+    return { _id: oid(id) };
+  } catch (e) {
+    return null;
+  }
 };
 
 /**
  * Construct in query of ObjectId array
- * @param {string value of the id} ids 
+ * @param {string value of the id} ids
  * @returns id in query if id is valid otherwise return null
  */
 const oid_queries = (ids) => {
-    try {
-        const id_array = ids.map(id => oid(id));
-        return { _id: { $in: id_array } };
-    } catch (e) {
-        return null;
-    }
+  try {
+    const id_array = ids.map((id) => oid(id));
+    return { _id: { $in: id_array } };
+  } catch (e) {
+    return null;
+  }
 };
 
 /**
  * Execute bulk update using the items
- * @param {mongodb collection} col 
- * @param {the items to execute bulk update} items 
- * @param {the attributes used as search criteria} attrs 
- * @returns 
+ * @param {mongodb collection} col
+ * @param {the items to execute bulk update} items
+ * @param {the attributes used as search criteria} attrs
+ * @returns
  */
 const bulk_update = async (col, items, attrs) => {
-    const bulk = col.initializeOrderedBulkOp();
-    for (const item of items) {
-        const query = {};
-        attrs.forEach(function (attr) {
-            query[attr] = item[attr];
-        });
-        bulk.find(query).upsert().update({ "$set": item }, true);
-    }
-    return await bulk.execute();
+  const bulk = col.initializeOrderedBulkOp();
+  for (const item of items) {
+    const query = {};
+    attrs.forEach(function (attr) {
+      query[attr] = item[attr];
+    });
+    bulk.find(query).upsert().update({ $set: item }, true);
+  }
+  return await bulk.execute();
 };
 
 class DB {
-
-    constructor(url, poolSize) {
-        if (!url) {
-            return;
-        }
-
-        this.db = mongoist(url, { autoReconnect: true, poolSize: poolSize });
-
-        this.db.on('error', function (err) {
-            if (is_log_error()) {
-                log_error(LOG_DB, err);
-            }
-        });
-    }
-
-    /**
-     * Insert Object to db
-     * @param {mongodb collection name} code 
-     * @param {inserted object} obj 
-     * @returns 
-     */
-    create(code, obj) {
-        const col = this.db[code];
-        return col.insert(obj);
+  constructor(url, poolSize) {
+    if (!url) {
+      return;
     }
 
-    /**
-     * Update the object, upsert:true, multi:true
-     * @param {mongodb collection name} code 
-     * @param {*} query 
-     * @param {*} obj 
-     * @returns 
-     */
-    update(code, query, obj) {
-        if (is_log_debug()) {
-            log_debug(LOG_DB, "updating obj:" + JSON.stringify(obj) + ", for [" + code + "] with query:" + JSON.stringify(query));
-        }
-
-        const col = this.db[code];
-        return col.update(query, { "$set": obj }, { upsert: true, multi: true });
+    this.db = mongoist(url, { autoReconnect: true, poolSize: poolSize });
+
+    this.db.on("error", function (err) {
+      if (is_log_error()) {
+        log_error(LOG_DB, err);
+      }
+    });
+  }
+
+  /**
+   * Insert Object to db
+   * @param {mongodb collection name} code
+   * @param {inserted object} obj
+   * @returns
+   */
+  create(code, obj) {
+    const col = this.db[code];
+    return col.insert(obj, { checkKeys: false });
+  }
+
+  /**
+   * Update the object, upsert:true, multi:true
+   * @param {mongodb collection name} code
+   * @param {*} query
+   * @param {*} obj
+   * @returns
+   */
+  update(code, query, obj) {
+    if (is_log_debug()) {
+      log_debug(LOG_DB, "updating obj:" + JSON.stringify(obj) + ", for [" + code + "] with query:" + JSON.stringify(query));
     }
 
-    /**
-     * Remove the records from mongodb
-     * @param {mongodb collection name} code 
-     * @param {query to execute delete op} query 
-     * @returns 
-     */
-    delete(code, query) {
-        if (is_log_debug()) {
-            log_debug(LOG_DB, "deleting objects for [" + code + "] with query:" + JSON.stringify(query));
-        }
-
-        const col = this.db[code];
-        return col.remove(query);
+    const col = this.db[code];
+    return col.update(query, { $set: obj }, { upsert: true, multi: true });
+  }
+
+  /**
+   * Remove the records from mongodb
+   * @param {mongodb collection name} code
+   * @param {query to execute delete op} query
+   * @returns
+   */
+  delete(code, query) {
+    if (is_log_debug()) {
+      log_debug(LOG_DB, "deleting objects for [" + code + "] with query:" + JSON.stringify(query));
     }
 
-    /**
-     * Search the db using query
-     * @param {mongodb collection name} code 
-     * @param {search criteria} query 
-     * @param {the attributes to load from db} attr 
-     * @returns 
-     */
-    find(code, query, attr) {
-        if (is_log_debug()) {
-            log_debug(LOG_DB, "find objects for [" + code + "] with query:" + JSON.stringify(query) + " and attr:" + JSON.stringify(attr));
-        }
-
-        const col = this.db[code];
-        return col.find(query, attr);
+    const col = this.db[code];
+    return col.remove(query);
+  }
+
+  /**
+   * Search the db using query
+   * @param {mongodb collection name} code
+   * @param {search criteria} query
+   * @param {the attributes to load from db} attr
+   * @returns
+   */
+  find(code, query, attr) {
+    if (is_log_debug()) {
+      log_debug(LOG_DB, "find objects for [" + code + "] with query:" + JSON.stringify(query) + " and attr:" + JSON.stringify(attr));
     }
 
-    /**
-     * Find one record from db
-     * @param {mongodb collection name} code 
-     * @param {search criteria} query 
-     * @param {the attributes to load from db} attr 
-     * @returns 
-     */
-    find_one(code, query, attr) {
-        if (is_log_debug()) {
-            log_debug(LOG_DB, "find_one for [" + code + "] with query:" + JSON.stringify(query) + " and attr:" + JSON.stringify(attr));
-        }
-
-        const col = this.db[code];
-        return col.findOne(query, attr);
+    const col = this.db[code];
+    return col.find(query, attr);
+  }
+
+  /**
+   * Find one record from db
+   * @param {mongodb collection name} code
+   * @param {search criteria} query
+   * @param {the attributes to load from db} attr
+   * @returns
+   */
+  find_one(code, query, attr) {
+    if (is_log_debug()) {
+      log_debug(LOG_DB, "find_one for [" + code + "] with query:" + JSON.stringify(query) + " and attr:" + JSON.stringify(attr));
     }
 
-    /**
-     * Find the records from db using sort to do sorting
-     * @param {mongodb collection name} code 
-     * @param {search criteria} query 
-     * @param {sort object to sort the result} sort 
-     * @param {the attributes of the object to load from db} attr 
-     * @returns 
-     */
-    find_sort(code, query, sort, attr) {
-        if (is_log_debug()) {
-            log_debug(LOG_DB, "find_sort for [" + code + "] with query:" + JSON.stringify(query) + " and attr:" + JSON.stringify(attr) + " and sort:" + JSON.stringify(sort));
-        }
-
-        const col = this.db[code];
-        return col.find(query, attr, { sort: sort });
+    const col = this.db[code];
+    return col.findOne(query, attr);
+  }
+
+  /**
+   * Find the records from db using sort to do sorting
+   * @param {mongodb collection name} code
+   * @param {search criteria} query
+   * @param {sort object to sort the result} sort
+   * @param {the attributes of the object to load from db} attr
+   * @returns
+   */
+  find_sort(code, query, sort, attr) {
+    if (is_log_debug()) {
+      log_debug(LOG_DB, "find_sort for [" + code + "] with query:" + JSON.stringify(query) + " and attr:" + JSON.stringify(attr) + " and sort:" + JSON.stringify(sort));
     }
 
-    /**
-     * Find the page records
-     * @param {mongodb collection name} code 
-     * @param {search criteria} query 
-     * @param {sort object to sort the results} sort 
-     * @param {the page index to load} page 
-     * @param {page size } limit 
-     * @param {the attributes of the object to load from db} attr 
-     * @returns 
-     */
-    find_page(code, query, sort, page, limit, attr) {
-        if (is_log_debug()) {
-            log_debug(LOG_DB, "find_page for [" + code + "] with query:" + JSON.stringify(query) + " and attr:" + JSON.stringify(attr) + " and sort:" + JSON.stringify(sort) + ", page:" + page + ",limit:" + limit);
-        }
-
-        const skip = (page - 1) * limit > 0 ? (page - 1) * limit : 0;
-        const col = this.db[code];
-        return col.find(query, attr, { sort: sort, skip: skip, limit: limit });
+    const col = this.db[code];
+    return col.find(query, attr, { sort: sort });
+  }
+
+  /**
+   * Find the page records
+   * @param {mongodb collection name} code
+   * @param {search criteria} query
+   * @param {sort object to sort the results} sort
+   * @param {the page index to load} page
+   * @param {page size } limit
+   * @param {the attributes of the object to load from db} attr
+   * @returns
+   */
+  find_page(code, query, sort, page, limit, attr) {
+    if (is_log_debug()) {
+      log_debug(LOG_DB, "find_page for [" + code + "] with query:" + JSON.stringify(query) + " and attr:" + JSON.stringify(attr) + " and sort:" + JSON.stringify(sort) + ", page:" + page + ",limit:" + limit);
     }
 
-    /**
-     * The count number of the query
-     * @param {mongodb collection name} code 
-     * @param {search criteria} query 
-     * @returns 
-     */
-    count(code, query) {
-        if (is_log_debug()) {
-            log_debug(LOG_DB, "count for [" + code + "] with query:" + JSON.stringify(query));
-        }
-
-        const col = this.db[code];
-        return col.count(query);
+    const skip = (page - 1) * limit > 0 ? (page - 1) * limit : 0;
+    const col = this.db[code];
+    return col.find(query, attr, { sort: sort, skip: skip, limit: limit });
+  }
+
+  /**
+   * The count number of the query
+   * @param {mongodb collection name} code
+   * @param {search criteria} query
+   * @returns
+   */
+  count(code, query) {
+    if (is_log_debug()) {
+      log_debug(LOG_DB, "count for [" + code + "] with query:" + JSON.stringify(query));
     }
 
-    /**
-     * Calculate the sum value based on the field and query criteria
-     * @param {mongodb collection name} code 
-     * @param {search criteria} query 
-     * @param {field name to calculate sum} field 
-     * @returns 
-     */
-    sum(code, query, field) {
-        if (is_log_debug()) {
-            log_debug(LOG_DB, "sum for [" + code + "] with query:" + JSON.stringify(query) + ", and field:" + JSON.stringify(field));
-        }
-
-        const col = this.db[code];
-        return col.aggregate([{ "$match": query }, { "$group": { _id: null, total: { "$sum": "$" + field + "" } } }])
-            .then(result => result.length > 0 ? result[0].total : 0);
+    const col = this.db[code];
+    return col.count(query);
+  }
+
+  /**
+   * Calculate the sum value based on the field and query criteria
+   * @param {mongodb collection name} code
+   * @param {search criteria} query
+   * @param {field name to calculate sum} field
+   * @returns
+   */
+  sum(code, query, field) {
+    if (is_log_debug()) {
+      log_debug(LOG_DB, "sum for [" + code + "] with query:" + JSON.stringify(query) + ", and field:" + JSON.stringify(field));
     }
 
-    /**
-     * Pull the object from array
-     * @param {mongodb collection name} code 
-     * @param {search criteria} query 
-     * @param {object pulled from the array} ele 
-     * @returns 
-     */
-    pull(code, query, ele) {
-        if (is_log_debug()) {
-            log_debug(LOG_DB, "pull ele [" + JSON.stringify(ele) + "] with query:" + JSON.stringify(query) + ",code:" + code);
-        }
-
-        const col = this.db[code];
-        return col.update(query, { "$pull": ele }, { multi: true });
+    const col = this.db[code];
+    return col.aggregate([{ $match: query }, { $group: { _id: null, total: { $sum: "$" + field + "" } } }]).then((result) => (result.length > 0 ? result[0].total : 0));
+  }
+
+  /**
+   * Pull the object from array
+   * @param {mongodb collection name} code
+   * @param {search criteria} query
+   * @param {object pulled from the array} ele
+   * @returns
+   */
+  pull(code, query, ele) {
+    if (is_log_debug()) {
+      log_debug(LOG_DB, "pull ele [" + JSON.stringify(ele) + "] with query:" + JSON.stringify(query) + ",code:" + code);
     }
 
-    /**
-     * Push the object to array
-     * @param {mongodb collection name} code 
-     * @param {search criteria} query 
-     * @param {object push to the array} ele 
-     * @returns 
-     */
-    push(code, query, ele) {
-        if (is_log_debug()) {
-            log_debug(LOG_DB, "push ele [" + JSON.stringify(ele) + "] with query:" + JSON.stringify(query) + ",code:" + code);
-        }
-
-        const col = this.db[code];
-        return col.update(query, { "$push": ele });
+    const col = this.db[code];
+    return col.update(query, { $pull: ele }, { multi: true });
+  }
+
+  /**
+   * Push the object to array
+   * @param {mongodb collection name} code
+   * @param {search criteria} query
+   * @param {object push to the array} ele
+   * @returns
+   */
+  push(code, query, ele) {
+    if (is_log_debug()) {
+      log_debug(LOG_DB, "push ele [" + JSON.stringify(ele) + "] with query:" + JSON.stringify(query) + ",code:" + code);
     }
 
-    /**
-    * add the object to set
-    * @param {mongodb collection name} code 
-    * @param {search criteria} query 
-    * @param {object added to the set} ele 
-    * @returns 
-    */
-    add_to_set(code, query, ele) {
-        const col = this.db[code];
-        return col.update(query, { "$addToSet": ele }, { upsert: true });
-    };
-
-    /**
-     * Get the mongodb collection
-     * @param {mongodb collection name} code 
-     * @returns 
-     */
-    col(code) {
-        return this.db[code];
-    }
+    const col = this.db[code];
+    return col.update(query, { $push: ele });
+  }
+
+  /**
+   * add the object to set
+   * @param {mongodb collection name} code
+   * @param {search criteria} query
+   * @param {object added to the set} ele
+   * @returns
+   */
+  add_to_set(code, query, ele) {
+    const col = this.db[code];
+    return col.update(query, { $addToSet: ele }, { upsert: true });
+  }
+
+  /**
+   * Get the mongodb collection
+   * @param {mongodb collection name} code
+   * @returns
+   */
+  col(code) {
+    return this.db[code];
+  }
 }
 
 let db_instance = new DB();
 
 /**
- * 
+ *
  * @returns db instance of mongodb
  */
 const get_db = () => {
-    if (db_instance && db_instance.db) {
-        return db_instance;
-    } else {
-        const mongo = get_settings().mongo;
-
-        db_instance = new DB(mongo.url, mongo.pool);
-        return db_instance;
-    }
-}
+  if (db_instance && db_instance.db) {
+    return db_instance;
+  } else {
+    const mongo = get_settings().mongo;
+
+    db_instance = new DB(mongo.url, mongo.pool);
+    return db_instance;
+  }
+};
 
 module.exports = { oid, oid_query, oid_queries, bulk_update, get_db, log_debug, log_info, log_warn, log_error, is_log_debug, is_log_info, is_log_warn, is_log_error, LOG_DB, LOG_SYSTEM, LOG_ENTITY, get_session_userid };

package/package.json

@@ -1,29 +1,29 @@
 {
   "name": "hola-server",
-  "version": "0.3.3",
+  "version": "0.3.6",
   "description": "a meta programming framework used to build nodejs restful api",
   "main": "index.js",
   "scripts": {
     "test": "mocha --timeout 10000 --recursive './test/*/*.js'"
   },
   "dependencies": {
-    "axios": "^0.21.1",
-    "body-parser": "^1.19.0",
-    "connect-mongo": "^4.4.1",
+    "axios": "^0.27.2",
+    "body-parser": "^1.20.0",
+    "connect-mongo": "^4.6.0",
     "cors": "^2.8.5",
     "dateformat": "^4.5.1",
-    "express": "^4.17.1",
-    "express-sanitizer": "^1.0.5",
-    "express-session": "^1.17.1",
-    "mongodb": "^3.6.5",
-    "mongoist": "^2.5.3",
-    "multer": "^1.4.2",
+    "express": "^4.18.1",
+    "express-sanitizer": "^1.0.6",
+    "express-session": "^1.17.3",
+    "mongodb": "^4.7.0",
+    "mongoist": "^2.5.4",
+    "multer": "^1.4.5-lts.1",
     "unzipper": "^0.10.11"
   },
   "devDependencies": {
-    "chai": "^3.5.0",
-    "chai-http": "^2.0.1",
-    "mocha": "^2.4.5"
+    "chai": "^4.3.6",
+    "chai-http": "^4.3.0",
+    "mocha": "^10.0.0"
   },
   "repository": {
     "type": "git",

package/test/db/db.js

@@ -1,58 +1,72 @@
-const { strictEqual } = require('assert');
-const { get_db } = require('../../db/db');
+const { strictEqual } = require("assert");
+const { get_db } = require("../../db/db");
 const db = get_db();
 const user_code = "user";
 
-describe('mongodb', function () {
-    describe('create', function () {
-        it('should create user successfully', async function () {
-            const birthday = new Date();
-            const user = { "name": "user1", age: 10, male: true, birthday: birthday };
-            const result = await db.create(user_code, user);
-            strictEqual(result.name, "user1");
-            strictEqual(result.age, 10);
-            strictEqual(result.male, true);
-            strictEqual(result.birthday, birthday);
-
-            await db.delete(user_code, {});
-        });
+describe("mongodb", function () {
+  describe("create", function () {
+    it("should create user successfully", async function () {
+      const birthday = new Date();
+      const user = { name: "user1", age: 10, male: true, birthday: birthday };
+      const result = await db.create(user_code, user);
+      strictEqual(result.name, "user1");
+      strictEqual(result.age, 10);
+      strictEqual(result.male, true);
+      strictEqual(result.birthday, birthday);
+
+      await db.delete(user_code, {});
+    });
+  });
+
+  describe("create", function () {
+    it("should create user with dotted key successfully", async function () {
+      const birthday = new Date();
+      const user = { "name.key": "user1", age: 10, male: true, birthday: birthday };
+      const result = await db.create(user_code, user);
+      strictEqual(result["name.key"], "user1");
+      strictEqual(result.age, 10);
+      strictEqual(result.male, true);
+      strictEqual(result.birthday, birthday);
+
+      await db.delete(user_code, {});
     });
+  });
 
-    describe('update', function () {
-        it('should update user successfully', async function () {
-            const birthday = new Date();
-            const user = { "name": "user1", age: 10, male: true, birthday: birthday };
-            await db.create(user_code, user);
+  describe("update", function () {
+    it("should update user successfully", async function () {
+      const birthday = new Date();
+      const user = { name: "user1", age: 10, male: true, birthday: birthday };
+      await db.create(user_code, user);
 
-            const query = { "name": "user1" };
-            await db.update(user_code, query, { age: 20 });
+      const query = { name: "user1" };
+      await db.update(user_code, query, { age: 20 });
 
-            const db_user = await db.find_one(user_code, query);
-            strictEqual(db_user.name, "user1");
-            strictEqual(db_user.age, 20);
-            strictEqual(db_user.male, true);
+      const db_user = await db.find_one(user_code, query);
+      strictEqual(db_user.name, "user1");
+      strictEqual(db_user.age, 20);
+      strictEqual(db_user.male, true);
 
-            const db_user_name = await db.find_one(user_code, query, { "age": 1 });
-            strictEqual(db_user_name.name, undefined);
-            strictEqual(db_user_name.male, undefined);
-            strictEqual(db_user_name.birthday, undefined);
-            strictEqual(db_user_name.age, 20);
+      const db_user_name = await db.find_one(user_code, query, { age: 1 });
+      strictEqual(db_user_name.name, undefined);
+      strictEqual(db_user_name.male, undefined);
+      strictEqual(db_user_name.birthday, undefined);
+      strictEqual(db_user_name.age, 20);
 
-            await db.delete(user_code, {});
-        });
+      await db.delete(user_code, {});
     });
+  });
 
-    describe('count', function () {
-        it('should get user count successfully', async function () {
-            const birthday = new Date();
-            const user = { "name": "user1", age: 10, male: true, birthday: birthday };
-            await db.create(user_code, user);
-            const query = { "name": "user1" };
+  describe("count", function () {
+    it("should get user count successfully", async function () {
+      const birthday = new Date();
+      const user = { name: "user1", age: 10, male: true, birthday: birthday };
+      await db.create(user_code, user);
+      const query = { name: "user1" };
 
-            const user_count = await db.count(user_code, query);
-            strictEqual(user_count, 1)
+      const user_count = await db.count(user_code, query);
+      strictEqual(user_count, 1);
 
-            await db.delete(user_code, {});
-        });
+      await db.delete(user_code, {});
     });
-});
+  });
+});