hola-server 0.3.18 → 0.3.21

package/core/meta.js

@@ -12,8 +12,10 @@ const meta_manager = {};
  * create is false, this attribute can be shown in property list but sys property can't be shown in property list 
  * 
  * routes: configure customer defined routes
+ * link property: field link property link to entity field and the field should ref to an entity.
+ * and the field name should be the same with the ref entity field name and shouldn't make as required and no other property
 */
-const field_attrs = ["name", "type", "required", "ref", "delete", "create", "list", "search", "update", "clone", "sys"];
+const field_attrs = ["name", "type", "required", "ref", "link", "delete", "create", "list", "search", "update", "clone", "sys"];
 const meta_attrs = ["collection", "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"];
@@ -37,14 +39,16 @@ const validate_field = (meta, field) => {
     if (field.type) {
         get_type(field.type);
     } else {
-        field.type = "string";
+        if (!field.link) {
+            field.type = "string"
+        }
     }
 
     if (meta.primary_keys.includes(field.name)) {
         field.required = true;
     }
 
-    if (field.ref) {
+    if (field.ref && !field.link) {
         const ref_meta = meta_manager[field.ref];
         if (!ref_meta) {
             throw new Error("meta:" + meta.collection + ",field:" + field.name + " refers invalid meta:" + field.ref + "]");
@@ -71,6 +75,16 @@ const validate_field = (meta, field) => {
         }
     }
 
+    if (field.link) {
+        const keys = Object.keys(field);
+        const support_keys_for_links = ["name", "link", "list"]
+        keys.forEach(key => {
+            if (!support_keys_for_links.includes(key)) {
+                throw new Error("Link field just supports name, link,list property. The attribute [" + key + "] isn't supported for LINK field:" + JSON.stringify(field) + " and meta:" + meta.collection);
+            }
+        });
+    }
+
     const keys = Object.keys(field);
     keys.forEach(key => {
         if (!field_attrs.includes(key)) {
@@ -85,13 +99,35 @@ const validate_field = (meta, field) => {
  * @param {meta fields} fields 
  */
 const validate_fields = (meta, fields) => {
-    const field_names = [];
+    const fields_map = fields.reduce((map, field) => { map[field.name] = field; return map; }, {});
+    const check_duplicate_field_names = [];
+
     fields.forEach(field => {
         validate_field(meta, field);
-        if (field_names.includes(field.name)) {
+        if (check_duplicate_field_names.includes(field.name)) {
             throw new Error("Duplicate field defined [" + JSON.stringify(field) + "] for meta:" + meta.collection);
         } else {
-            field_names.push(field.name);
+            check_duplicate_field_names.push(field.name);
+        }
+        if (field.link) {
+            const link_field = fields_map[field.link];
+            if (!link_field) {
+                throw new Error("link field [" + JSON.stringify(field) + "] should link to one field defined in meta:" + meta.collection);
+            } else {
+                if (!link_field.ref) {
+                    throw new Error("link field [" + JSON.stringify(field) + "] link to field [" + JSON.stringify(link_field) + "] should ref to one entity in meta:" + meta.collection);
+                }
+                const entity = get_entity_meta(link_field.ref);
+                const link_entity_field = entity.fields_map[field.name];
+                if (!link_entity_field) {
+                    throw new Error("link field [" + JSON.stringify(field) + "] should link to one field defined in meta:" + entity.collection);
+                }
+                //set type to link field type
+                field.type = link_entity_field.type;
+                if (link_entity_field.ref) {
+                    field.ref = link_entity_field.ref;
+                }
+            }
         }
     });
 
@@ -167,22 +203,24 @@ class EntityMeta {
         this.ref_fields = this.meta.fields.filter(field => field.ref);
         this.ref_by_metas = [];
 
+        this.link_fields = this.meta.fields.filter(field => field.link);
+        this.fields_map = meta.fields.reduce((map, field) => { map[field.name] = field; return map; }, {});
         this.fields = meta.fields;
         this.primary_keys = meta.primary_keys;
         this.field_names = this.fields.map(field => field.name);
         this.user_field = meta.user_field;
 
         this.property_fields = this.fields.filter(field => field.sys != true);
-        this.create_fields = this.fields.filter(field => field.create != false && field.sys != true);
-        this.update_fields = this.fields.filter(field => field.create != false && field.update != false && field.sys != true);
-        this.search_fields = this.fields.filter(field => field.search != false && field.sys != true);
-        this.clone_fields = this.fields.filter(field => field.clone != false && field.sys != true);
+        this.create_fields = this.fields.filter(field => field.create != false && field.sys != true && !field.link);
+        this.update_fields = this.fields.filter(field => field.create != false && field.update != false && field.sys != true && !field.link);
+        this.search_fields = this.fields.filter(field => field.search != false && field.sys != true && !field.link);
+        this.clone_fields = this.fields.filter(field => field.clone != false && field.sys != true && !field.link);
         this.list_fields = this.fields.filter(field => field.list != false && field.sys != true);
         this.primary_key_fields = this.fields.filter(field => meta.primary_keys.includes(field.name));
         this.required_field_names = this.fields.filter(field => field.required == true || this.primary_keys.includes(field.name)).map(field => field.name);
 
         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 })) : [];
+        this.upload_fields = this.file_fields && this.file_fields.length > 0 ? this.file_fields.map(f => ({ name: f.name })) : [];
 
         set_callback(this, "after_read", meta.after_read);
         set_callback(this, "before_create", meta.before_create);

package/db/entity.js

@@ -180,10 +180,20 @@ class Entity {
         });
 
         const list_field_names = this.meta.list_fields.map(f => f.name);
+        const ref_fields = [];
+        const link_fields = [];
+
         const attrs = {};
-        attr_names.split(",").forEach(function (attr) {
+        attr_names.split(",").forEach((attr) => {
             if (list_field_names.includes(attr)) {
                 attrs[attr] = 1;
+                const field = this.meta.fields_map[attr];
+                if (field.link) {
+                    link_fields.push(field);
+                    attrs[field.link] = 1;
+                } else if (field.ref) {
+                    ref_fields.push(field);
+                }
             }
         });
 
@@ -203,7 +213,8 @@ class Entity {
 
         const total = await this.count(search_query);
         const list = await this.find_page(search_query, sort, page_int, page_limit, attrs);
-        const data = await this.convert_ref_attrs(list);
+        const list_link = await this.read_link_attrs(list, link_fields);
+        const data = await this.convert_ref_attrs(list_link, ref_fields);
 
         if (is_log_debug()) {
             log_debug(LOG_ENTITY, "total:" + total + ",data:" + JSON.stringify(data));
@@ -520,17 +531,18 @@ class Entity {
     }
 
     /**
-     * Validate the param object and invoke the logic to read entity
-     * this is used for update entity
+     * Use objectid to read entity properties. Validate the param object and invoke the logic to read entity properties.
+     * This method doesn't convert ref property, so all the ref properties are objectid of the ref entity.
+     * It also donesn't inclue link property. This is used for form view to do create/update the entity.
      * @param {object id of the entity} _id object id of the entity
      * @param {attr names to retrieve} attr_names
      *
      */
-    async read_entity(_id, attr_names) {
+    async read_property(_id, attr_names) {
         const query = oid_query(_id);
         if (query == null) {
             if (is_log_error()) {
-                log_error(LOG_ENTITY, "read_entity invalid id:" + _id);
+                log_error(LOG_ENTITY, "read_property invalid id:" + _id);
             }
             return { code: INVALID_PARAMS, err: ["_id"] };
         }
@@ -546,7 +558,7 @@ class Entity {
         const results = await this.find(query, attrs);
         if (results && results.length == 1) {
             if (is_log_debug()) {
-                log_debug("read entity with query:" + JSON.stringify(query) + ",attrs:" + JSON.stringify(attrs) + ",result:" + JSON.stringify(results));
+                log_debug("read_property with query:" + JSON.stringify(query) + ",attrs:" + JSON.stringify(attrs) + ",result:" + JSON.stringify(results));
             }
             return { code: SUCCESS, data: results[0] };
         } else {
@@ -555,33 +567,42 @@ class Entity {
     }
 
     /**
-   * Validate the param object and invoke the logic to read entity properties
-   * this is used for update entity
-   * @param {object id of the entity} _id object id of the entity
-   * @param {attr names to retrieve} attr_names
-   *
-   */
-    async read_entity_properties(_id, attr_names) {
+     * Use objectid to read entity properties. Validate the param object and invoke the logic to read entity properties.
+     * It will convert object ref attributes to ref_label property of the ref entity and also read link attributes.
+     * @param {object id of the entity} _id object id of the entity
+     * @param {attr names to retrieve} attr_names
+     *
+     */
+    async read_entity(_id, attr_names) {
         const query = oid_query(_id);
         if (query == null) {
             if (is_log_error()) {
-                log_error(LOG_ENTITY, "read_entity_properties invalid id:" + _id);
+                log_error(LOG_ENTITY, "read_entity invalid id:" + _id);
             }
             return { code: INVALID_PARAMS, err: ["_id"] };
         }
 
         if (!attr_names) {
             if (is_log_error()) {
-                log_error(LOG_ENTITY, "read_entity_properties invalid attr_names:" + attr_names);
+                log_error(LOG_ENTITY, "read_entity invalid attr_names:" + attr_names);
             }
             return { code: INVALID_PARAMS, err: ["attr_names"] };
         }
 
         const field_names = this.meta.property_fields.map(f => f.name);
+        const ref_fields = [];
+        const link_fields = [];
         const attrs = {};
         attr_names.split(",").forEach(function (attr) {
             if (field_names.includes(attr)) {
                 attrs[attr] = 1;
+                const field = this.meta.fields_map[attr];
+                if (field.link) {
+                    link_fields.push(field);
+                    attrs[field.link] = 1;
+                } else if (field.ref) {
+                    ref_fields.push(field);
+                }
             }
         });
 
@@ -597,10 +618,12 @@ class Entity {
                 }
             }
 
-            const converted = await this.convert_ref_attrs(results);
+            const list_link = await this.read_link_attrs(results, link_fields);
+            const converted = await this.convert_ref_attrs(list_link, ref_fields);
+
             if (converted && converted.length == 1) {
                 if (is_log_debug()) {
-                    log_debug("read_entity_properties with query:" + JSON.stringify(query) + ",attrs:" + JSON.stringify(attrs) + ",converted:" + JSON.stringify(converted));
+                    log_debug("read_entity with query:" + JSON.stringify(query) + ",attrs:" + JSON.stringify(attrs) + ",converted:" + JSON.stringify(converted));
                 }
                 return { code: SUCCESS, data: converted[0] };
             }
@@ -877,17 +900,17 @@ class Entity {
      * @param {element of object} elements 
      * @returns 
      */
-    async convert_ref_attrs(elements) {
-        if (elements && this.meta.ref_fields) {
-            for (let i = 0; i < this.meta.ref_fields.length; i++) {
-                const ref_field = this.meta.ref_fields[i];
+    async convert_ref_attrs(elements, ref_fields) {
+        if (elements && ref_fields && ref_fields.length > 0) {
+            for (let i = 0; i < ref_fields.length; i++) {
+                const ref_field = ref_fields[i];
                 let id_array = [];
                 for (let j = 0; j < elements.length; j++) {
                     const obj = elements[j];
                     const value = obj[ref_field.name];
                     if (Array.isArray(value)) {
                         id_array = id_array.concat(value);
-                    } else {
+                    } else if (value) {
                         id_array.push(value);
                     }
                 }
@@ -896,13 +919,16 @@ class Entity {
                 const ref_meta = get_entity_meta(ref_field.ref);
                 const ref_entity = new Entity(ref_meta);
                 const ref_labels = await ref_entity.get_ref_labels(id_array);
-                const label_map_obj = map_array_to_obj(ref_labels, "_id", ref_meta.ref_label);
+                const id_key = "_id";
+                const label_map_obj = map_array_to_obj(ref_labels, id_key, ref_meta.ref_label);
                 for (let j = 0; j < elements.length; j++) {
                     const obj = elements[j];
                     const value = obj[ref_field.name];
+                    obj[ref_field.name + id_key] = value;
+
                     if (Array.isArray(value)) {
                         obj[ref_field.name] = value.map(v => label_map_obj[v]);
-                    } else {
+                    } else if (value) {
                         obj[ref_field.name] = label_map_obj[value];
                     }
                 }
@@ -911,6 +937,84 @@ class Entity {
         return elements;
     }
 
+    /**
+     * read the link attrs
+     * @param {*} elements 
+     * @returns 
+     */
+    async read_link_attrs(elements, link_fields) {
+        if (elements && link_fields && link_fields.length > 0) {
+            //key is entity name, value is array of fields
+            const entity_attr_map = link_fields.reduce((map, field) => {
+                const link_field = this.meta.fields_map[field.link];
+                if (map[link_field.ref]) {
+                    map[link_field.ref].push(field.name);
+                } else {
+                    map[link_field.ref] = [field.name];
+                }
+                return map;
+            }, {});
+
+            //key entity, value: attr property used to query
+            const entity_filter_map = link_fields.reduce((map, field) => {
+                const link_field = this.meta.fields_map[field.link];
+                if (map[link_field.ref]) {
+                    (!map[link_field.ref].includes(link_field.name)) && map[link_field.ref].push(link_field.name);
+                } else {
+                    map[link_field.ref] = [link_field.name];
+                }
+                return map;
+            }, {});
+
+            const entities = Object.keys(entity_filter_map);
+            for (let i = 0; i < entities.length; i++) {
+                const meta = get_entity_meta(entities[i]);
+                const entity = new Entity(meta);
+                let id_array = [];
+                for (let j = 0; j < elements.length; j++) {
+                    const obj = elements[j];
+                    const linked_attrs = entity_filter_map[entities[i]];
+                    for (let k = 0; k < linked_attrs.length; k++) {
+                        const id = obj[linked_attrs[k]];
+                        id_array.push(id);
+                    }
+                }
+                id_array = unique(id_array);
+                const query = oid_queries(id_array);
+                const attr_fields = entity_attr_map[entities[i]];
+                const attrs = {};
+                const ref_fields = [];
+                attr_fields.forEach((attr) => {
+                    attrs[attr] = 1;
+                    const field = meta.fields_map[attr];
+                    if (!field.link && field.ref) {
+                        ref_fields.push(field);
+                    }
+                });
+
+                const ref_entity_items = await entity.find(query, attrs);
+                if (ref_entity_items && ref_entity_items.length > 0) {
+                    await entity.convert_ref_attrs(ref_entity_items, ref_fields);
+
+                    for (let j = 0; j < elements.length; j++) {
+                        const obj = elements[j];
+                        const linked_attrs = entity_filter_map[entities[i]];
+                        for (let k = 0; k < linked_attrs.length; k++) {
+                            const id = obj[linked_attrs[k]];
+                            const [link_obj] = ref_entity_items.filter(o => o._id + "" == id);
+                            if (link_obj) {
+                                const copy_obj = { ...link_obj };
+                                delete copy_obj["_id"];
+                                elements[j] = { ...obj, ...copy_obj };
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return elements;
+    }
+
     /**
     * get ref labels of the object, use ref_filter
     * @returns 

package/package.json

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

package/router/read.js

@@ -59,7 +59,7 @@ const init_read_router = function (router, meta) {
         res.json({ code: code, err: err, total: total, data: data });
     }));
 
-    router.post('/read', wrap_http(async function (req, res) {
+    router.post('/read_entity', wrap_http(async function (req, res) {
         let params = required_post_params(req, ["_id", "attr_names"]);
         if (params === null) {
             res.json({ code: NO_PARAMS, err: '[_id,attr_names] checking params are failed!' });
@@ -74,7 +74,7 @@ const init_read_router = function (router, meta) {
         res.json({ code: code, err: err, data: data });
     }));
 
-    router.post('/read_properties', wrap_http(async function (req, res) {
+    router.post('/read_property', wrap_http(async function (req, res) {
         let params = required_post_params(req, ["_id", "attr_names"]);
         if (params === null) {
             res.json({ code: NO_PARAMS, err: '[_id,attr_names] checking params are failed!' });
@@ -82,7 +82,7 @@ const init_read_router = function (router, meta) {
         }
 
         const { _id, attr_names } = params;
-        const { code, err, data } = await entity.read_entity_properties(_id, attr_names);
+        const { code, err, data } = await entity.read_property(_id, attr_names);
         if (!has_value(code)) {
             throw new Error("the method should return code");
         }

package/test/core/meta.js

@@ -274,6 +274,68 @@ describe('EntityMeta', function () {
             });
         });
 
+        it('should fails for wrong link ', function () {
+            throws(() => {
+                const entity_meta1 = new EntityMeta({
+                    collection: "user_link1",
+                    primary_keys: ["name"],
+                    fields: [
+                        { name: "name", type: "string", required: true },
+                        { name: "role", type: "string", link: "other", required: true },
+                    ]
+                });
+                entity_meta1.validate_meta_info();
+            });
+            throws(() => {
+                const entity_meta1 = new EntityMeta({
+                    collection: "user_link2",
+                    primary_keys: ["name"],
+                    fields: [
+                        { name: "name", type: "string", required: true },
+                        { name: "role", type: "string", link: "other" },
+                    ]
+                });
+                entity_meta1.validate_meta_info();
+            });
+
+            throws(() => {
+                const entity_meta1 = new EntityMeta({
+                    collection: "user_link3",
+                    primary_keys: ["name"],
+                    fields: [
+                        { name: "name", type: "string", required: true },
+                        { name: "role", link: "other" },
+                    ]
+                });
+                entity_meta1.validate_meta_info();
+            });
+        });
+
+        it('should success for link ', function () {
+            const entity_meta1 = new EntityMeta({
+                collection: "role_link_other",
+                primary_keys: ["name"],
+                ref_label: "name",
+                fields: [
+                    { name: "name", type: "string", required: true },
+                    { name: "desc", type: "string", required: true },
+                ]
+            });
+
+            const entity_meta2 = new EntityMeta({
+                collection: "user_link_other",
+                primary_keys: ["name"],
+                fields: [
+                    { name: "name", type: "string", required: true },
+                    { name: "user_role", type: "string", ref: "role_link_other", required: true },
+                    { name: "desc", link: "user_role", list: true },
+                ]
+            });
+
+            strictEqual(entity_meta1.validate_meta_info(), true);
+            strictEqual(entity_meta2.validate_meta_info(), true);
+        });
+
         it('should fails for wrong primary key type', function () {
             throws(() => {
                 const entity_meta1 = new EntityMeta({

package/test/entity/read.js

@@ -1,4 +1,4 @@
-const { SUCCESS, ERROR, NO_PARAMS, INVALID_PARAMS, DUPLICATE_KEY, REF_NOT_FOUND } = require('../../http/code');
+const { SUCCESS, } = require('../../http/code');
 const { strictEqual, deepStrictEqual } = require('assert');
 const { Entity } = require('../../db/entity');
 const { EntityMeta } = require('../../core/meta');
@@ -18,7 +18,8 @@ const user = {
         { name: "role", type: "array", ref: "role_read", required: true },
         { name: "depart", type: "string", ref: "department_read", required: true },
         { name: "status", type: "boolean" },
-        { name: "desc", type: "string", search: false }
+        { name: "desc", type: "string", search: false },
+        { name: "people", link: "depart" },
     ]
 };
 
@@ -32,7 +33,8 @@ const department = {
     ref_label: "name",
     fields: [
         { name: "name", required: true },
-        { name: "desc", type: "string" }
+        { name: "people", type: "int" },
+        { name: "desc", type: "string" },
     ]
 };
 
@@ -65,6 +67,7 @@ const department_entity = new Entity(department_meta);
 const init_db = async () => {
     await user_entity.delete({});
     await role_entity.delete({});
+    await department_entity.delete({});
 
     await role_entity.create_entity({ name: "admin", status: true });
     await role_entity.create_entity({ name: "user", status: true });
@@ -72,8 +75,10 @@ const init_db = async () => {
     await role_entity.create_entity({ name: "user2", status: true });
     await role_entity.create_entity({ name: "user3", status: true });
 
-    await department_entity.create_entity({ name: "dev" });
-    await department_entity.create_entity({ name: "test" });
+    await department_entity.create_entity({ name: "dev", people: 20 });
+    const result = await department_entity.create_entity({ name: "test", people: 30 });
+    strictEqual(result.err, undefined);
+    strictEqual(result.code, SUCCESS);
 
     const { code, err } = await user_entity.create_entity({ "name": "user1", pwd: "pwd", age: "10", depart: "dev", role: "user", status: "true", email: "test@test.com", desc: "abcd" });
     strictEqual(err, undefined);
@@ -100,7 +105,7 @@ describe('Entity Query', function () {
         it('search user by name', async function () {
             await init_db();
 
-            const query = { "attr_names": "name,age", page: "1", limit: "10", sort_by: "name", desc: "true" };
+            const query = { "attr_names": "name,age,depart,people", page: "1", limit: "10", sort_by: "name", desc: "true" };
             const params = { age: "20" };
 
             const { code, err, total, data } = await user_entity.list_entity(query, null, params);
@@ -110,6 +115,8 @@ describe('Entity Query', function () {
             strictEqual(data.length, 3);
             strictEqual(data[0].age, 20);
             strictEqual(data[0].name, "user15");
+            strictEqual(data[0].people, 30);
+            strictEqual(data[0].depart, "test");
             strictEqual(data[0].status, undefined);
         });