hola-server 0.6.10 → 0.6.13

package/core/meta.js

@@ -13,6 +13,7 @@ const meta_manager = {};
  * create is false, this attribute can be shown in property list but sys property can't be shown in property list 
  * secure: secure properties will not be read by client, this is useful for password
  * group: this is used to control user sharing entities, this means the entity is shared by user group, this is only valid for user field
+ * view: this is used to control for edit form, for one entity, may have many forms to edit the entity, so use view to seperate them, this can be string or array
  * 
  * routes: configure customer defined routes
  * link property: field link property link to entity field and the field should ref to an entity.
@@ -20,7 +21,7 @@ const meta_manager = {};
  * 
  * 
 */
-const field_attrs = ["name", "type", "required", "ref", "link", "delete", "create", "list", "search", "update", "clone", "sys", "secure", "group"];
+const field_attrs = ["name", "type", "required", "ref", "link", "delete", "create", "list", "search", "update", "clone", "sys", "secure", "group", "view"];
 const meta_attrs = ["collection", "roles", "primary_keys", "fields", "creatable", "readable", "updatable", "deleteable", "cloneable", "after_read",
     "before_create", "after_create", "before_clone", "after_clone", "before_update", "after_update", "before_delete", "after_delete", "create", "clone", "update", "batch_update", "after_batch_update", "delete",
     "ref_label", "ref_filter", "route", "user_field"];
@@ -90,6 +91,19 @@ const validate_field = (meta, field) => {
         });
     }
 
+    const editable = (field.create != false) || (field.update != false);
+
+    if (field.view) {
+        if (!editable) {
+            throw new Error("view can just defined for editable (create/update) field only. Field:" + JSON.stringify(field) + "] and meta:" + meta.collection);
+        }
+    } else {
+        //no view defined for create/update field, then set view to default value "0"
+        if (editable) {
+            field.view = "0";
+        }
+    }
+
     const keys = Object.keys(field);
     keys.forEach(key => {
         if (!field_attrs.includes(key)) {
@@ -216,7 +230,8 @@ class EntityMeta {
         //b:batch mode, c:create, d:delete, e:export, i:import, o:clone, p:page, r: refresh, s:search, u:update
         const modes = [];
         this.creatable && (modes.push("c"));
-        this.readable && (modes.push("rps"));
+        //prefer the infinite scrolling mode, so doesn't include p mode
+        this.readable && (modes.push("rs"));
         this.updatable && (modes.push("u"));
         this.deleteable && (modes.push("db"));
         this.cloneable && (modes.push("o"));
@@ -302,9 +317,23 @@ class EntityMeta {
 
             this.roles.forEach(role => {
                 const role_config = role.split(":");
+                if (role_config.length != 2) {
+                    throw new Error("wrong role config [" + role + "] in meta [" + this.collection + "]. You should use : to seperate the role name with mode.");
+                }
+
                 const role_name = role_config[0];
                 if (!validate_meta_role(role_name)) {
-                    throw new Error("role [" + role_name + "] not defined in setting");
+                    throw new Error("role [" + role_name + "] in meta [" + this.collection + "] not defined in setting's role config.");
+                }
+
+                const role_mode = role_config[1];
+                if (role_mode != "*") {
+                    for (let i = 0; i < role_mode.length; i++) {
+                        const mode = role_mode.charAt(i);
+                        if (!this.mode.includes(mode)) {
+                            throw new Error("role [" + role_name + "] in meta [" + this.collection + "] with mode [" + mode + "] doesn't comply with entity mode [" + this.mode + "]");
+                        }
+                    }
                 }
             });
         }

package/core/role.js

@@ -1,7 +1,13 @@
 const { get_settings } = require("../setting");
 
+/**
+ * Validate the role defination in meta config
+ * @param {*} role_name 
+ * @returns 
+ */
 const validate_meta_role = (role_name) => {
     const settings = get_settings();
+    //there is role defined in meta but no roles config in settings
     if (!settings.roles) {
         return false;
     }
@@ -16,7 +22,7 @@ const is_valid_role = (role_name) => {
 
 const is_root_role = (role_name) => {
     const settings = get_settings();
-    //no role defined, then every one is root
+    //no role defined, then there is no role limition, so treat each user as root
     if (!settings.roles) {
         return true;
     }
@@ -28,11 +34,22 @@ const is_root_role = (role_name) => {
     }
 }
 
+/**
+ * get user's role from user session
+ * @param {request} req 
+ * @returns 
+ */
 const get_session_user_role = (req) => {
     const user = req && req.session ? req.session.user : null;
     return user ? user.role : null;
 }
 
+/**
+ * Get the meta mode based on user's role
+ * @param {request} req 
+ * @param {meta} meta 
+ * @returns 
+ */
 const get_user_role_mode = (req, meta) => {
     const settings = get_settings();
     //no role defined in settings or no roles defined in meta, use meta mode
@@ -53,14 +70,25 @@ const get_user_role_mode = (req, meta) => {
             const role_name = role_settings[0];
             const role_mode = role_settings[1];
             if (user_role == role_name) {
-                return role_mode;
+                // * stands to get the mode from meta definition
+                if (role_mode == "*") {
+                    return meta.mode;
+                } else {
+                    return role_mode;
+                }
             }
         }
     }
-
     return "";
 }
 
+/**
+ * Check whether the user has the mode right on the meta or not
+ * @param {http request} req 
+ * @param {meta defination} meta 
+ * @param {meta mode} mode 
+ * @returns 
+ */
 const check_user_role = (req, meta, mode) => {
     const role_mode = get_user_role_mode(req, meta);
     return role_mode.includes(mode);

package/db/entity.js

@@ -235,10 +235,11 @@ class Entity {
     /**
     * Validate the param object and invoke the logic to save it to db
     * @param {param obj from user input} param_obj
+    * @param {which view to create the entity} view
     * @returns object with code and err
     */
-    async create_entity(param_obj) {
-        const fields = this.meta.create_fields
+    async create_entity(param_obj, view) {
+        const fields = this.meta.create_fields.filter(field => field.view == view);
         const { obj, error_field_names } = convert_type(param_obj, fields);
         if (error_field_names.length > 0) {
             if (is_log_error()) {
@@ -397,10 +398,13 @@ class Entity {
      * Validate the param object and invoke the logic to update entity
      * @param {object id of the entity} _id object id of the entity, if it is null, then use primary key
      * @param {param object from user input} param_obj 
+     * @param {which view to update the entity} view 
      * 
      */
-    async update_entity(_id, param_obj) {
-        const { obj, error_field_names } = convert_update_type(param_obj, this.meta.update_fields);
+    async update_entity(_id, param_obj, view) {
+        const fields = this.meta.update_fields.filter(field => field.view == view);
+
+        const { obj, error_field_names } = convert_update_type(param_obj, fields);
         if (error_field_names.length > 0) {
             if (is_log_error()) {
                 log_error(LOG_ENTITY, "update_entity error fields:" + JSON.stringify(error_field_names));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hola-server",
-  "version": "0.6.10",
+  "version": "0.6.13",
   "description": "a meta programming framework used to build nodejs restful api",
   "main": "index.js",
   "scripts": {

package/router/create.js

@@ -26,6 +26,12 @@ const init_create_router = function (router, meta) {
             return;
         }
 
+        //which view to create the entity
+        let { _view } = post_params(req, ["_view"]);
+        if (!_view) {
+            _view = "0";
+        }
+
         const param_obj = post_params(req, meta.field_names);
         set_file_fields(meta, req, param_obj);
 
@@ -37,7 +43,7 @@ const init_create_router = function (router, meta) {
             param_obj[meta.user_field] = user_id;
         }
 
-        const { code, err } = await entity.create_entity(param_obj);
+        const { code, err } = await entity.create_entity(param_obj, _view);
         if (!has_value(code)) {
             throw new Error("the method should return code");
         }

package/router/update.js

@@ -1,5 +1,5 @@
 const { set_file_fields, save_file_fields_to_db } = require('../db/gridfs');
-const { required_post_params, post_update_params } = require('../http/params');
+const { required_post_params, post_update_params, post_params } = require('../http/params');
 const { SUCCESS, NO_PARAMS, NO_RIGHTS } = require('../http/code');
 const { check_user_role } = require('../http/session');
 const { has_value } = require('../core/validate');
@@ -36,10 +36,16 @@ const init_update_router = function (router, meta) {
             }
         }
 
+        //which view to update the entity
+        let { _view } = post_params(req, ["_view"]);
+        if (!_view) {
+            _view = "0";
+        }
+
         const param_obj = post_update_params(req, meta.field_names);
         set_file_fields(meta, req, param_obj);
 
-        const { code, err } = await entity.update_entity(params["_id"], param_obj);
+        const { code, err } = await entity.update_entity(params["_id"], param_obj, _view);
         if (!has_value(code)) {
             throw new Error("the method should return code");
         }