hola-server 0.3.11 → 0.3.14

package/db/entity.js

@@ -633,12 +633,13 @@ class Entity {
         }
 
         //check all the ref by array first
-        const has_refer_by_array = await this.check_refer_entity(id_array);
+        const has_refer_by_array = await this.check_refer_entity(this.meta.collection, id_array, id_array);
         if (has_refer_by_array.length > 0) {
+            const array = [...new Set(has_refer_by_array)];
             if (is_log_error()) {
-                log_error(LOG_ENTITY, "has_refer_by_array:" + JSON.stringify(has_refer_by_array));
+                log_error(LOG_ENTITY, "has_refer_by_array:" + JSON.stringify(array));
             }
-            return { code: HAS_REF, err: has_refer_by_array };
+            return { code: HAS_REF, err: array };
         }
 
         if (this.meta.delete) {
@@ -667,9 +668,7 @@ class Entity {
                 const ref_field = ref_fields[j];
                 if (ref_field.delete == DELETE_MODE.cascade) {
                     const refer_by_entity = new Entity(ref_by_meta);
-                    for (let j = 0; j < id_array.length; j++) {
-                        await refer_by_entity.delete_refer_entity(this.meta.collection, id_array[j])
-                    }
+                    await refer_by_entity.delete_refer_entity(ref_field.name, id_array)
                 }
             }
         }
@@ -803,12 +802,12 @@ class Entity {
     }
 
     /**
-       * check whether this entity has refered the entity_id value
-       * @param {entity collection} entity_name 
-       * @param {entity object id} entity_id 
-       * @returns true if has refered
-       */
-    async check_refer_entity(id_array) {
+     * 
+     * @param {the original collection name} collection 
+     * @param {the id array used to check} id_array 
+     * @returns refer by entities
+     */
+    async check_refer_entity(collection, collection_id_array, id_array) {
         const has_refer_by_array = [];
         for (let i = 0; i < this.meta.ref_by_metas.length; i++) {
             const ref_by_meta = this.meta.ref_by_metas[i];
@@ -818,23 +817,39 @@ class Entity {
             for (let j = 0; j < ref_fields.length; j++) {
                 const ref_field = ref_fields[j];
                 if (ref_field.delete != DELETE_MODE.keep) {
-                    for (let j = 0; j < id_array.length; j++) {
-                        const attrs = {};
-                        if (ref_by_meta.ref_label) {
-                            attrs[ref_by_meta.ref_label] = 1;
-                        }
-                        const entities = await refer_by_entity.get_refer_entities(this.meta.collection, id_array[j], attrs);
-                        if (entities && entities.length > 0) {
-                            if (ref_field.delete == DELETE_MODE.cascade) {
-                                const ref_array = await refer_by_entity.check_refer_entity(entities.map(o => o._id + ""));
-                                if (ref_array && ref_array.length > 0) {
-                                    has_refer_by_array.push(...ref_array);
+                    const attr = {};
+                    if (ref_by_meta.ref_label) {
+                        attr[ref_by_meta.ref_label] = 1;
+                    }
+
+                    const entities = await refer_by_entity.get_refer_entities(ref_field.name, id_array, attr);
+                    if (entities && entities.length > 0) {
+                        if (ref_field.delete == DELETE_MODE.cascade) {
+                            const ref_array = await refer_by_entity.check_refer_entity(collection, collection_id_array, entities.map(o => o._id + ""));
+                            if (ref_array && ref_array.length > 0) {
+                                has_refer_by_array.push(...ref_array);
+                            }
+                        } else {
+                            const ref_collection_fields = ref_by_meta.ref_fields.filter(field => field.ref == collection && field.delete == DELETE_MODE.cascade);
+                            const ref_entities_ids = [];
+                            const left_entities = [];
+                            for (let k = 0; k < ref_collection_fields.length; k++) {
+                                const ref_collection_field = ref_collection_fields[k];
+                                const ref_collection_entities = await refer_by_entity.get_refer_entities(ref_collection_field.name, collection_id_array, attr);
+                                ref_collection_entities && ref_collection_entities.length > 0 && ref_entities.push(...(ref_collection_entities.map(o => o["_id"] + "")));
+                            }
+                            for (let k = 0; k < entities.length; k++) {
+                                const entity = entities[k];
+                                if (!ref_entities_ids.includes(entity["_id"] + "")) {
+                                    left_entities.push(entity);
                                 }
-                            } else {
+                            }
+
+                            if (left_entities.length > 0) {
                                 if (ref_by_meta.ref_label) {
-                                    has_refer_by_array.push(...entities.map(o => o[ref_by_meta.ref_label]));
+                                    has_refer_by_array.push(...entities.map(o => this.meta.collection + "<-" + ref_by_meta.collection + ":" + o[ref_by_meta.ref_label]));
                                 } else {
-                                    has_refer_by_array.push(...entities.map(o => o["_id"] + ""));
+                                    has_refer_by_array.push(...entities.map(o => this.meta.collection + "<-" + ref_by_meta.collection + ":" + o["_id"] + ""));
                                 }
                             }
                         }
@@ -847,34 +862,23 @@ class Entity {
 
     /**
      * check whether this entity has refered the entity_id value
-     * @param {entity collection} entity_name 
-     * @param {entity object id} entity_id 
+     * @param {entity in this field name} field_name 
+     * @param {entity object id array} id_array 
      * @returns true if has refered
      */
-    async get_refer_entities(entity_name, entity_id, attr) {
-        const array = [];
-        if (this.meta.ref_fields) {
-            const fields = this.meta.ref_fields.filter(f => f.ref === entity_name);
-            if (fields.length > 0) {
-                for (let i = 0; i < fields.length; i++) {
-                    const field = fields[i];
-                    const query = { [field.name]: entity_id + "" };
-                    const founed = await this.find(query, attr);
-                    array.push(...founed);
-                }
-            }
-        }
-        return array;
+    async get_refer_entities(field_name, id_array, attr) {
+        console.log(id_array);
+        const query = { [field_name]: { "$in": id_array } };
+        return await this.find(query, attr);
     }
 
     /**
-     * delete the ref entity
-     * @param {entity collection} entity_name 
-     * @param {entity object id} entity_id 
-     * @returns 
+     * delete refer entities
+     * @param {entity in this field name} field_name 
+     * @param {entity object id array} id_array 
      */
-    async delete_refer_entity(entity_name, entity_id) {
-        const entities = await this.get_refer_entities(entity_name, entity_id, {});
+    async delete_refer_entity(field_name, id_array) {
+        const entities = await this.get_refer_entities(field_name, id_array, {});
         await this.delete_entity(entities.map(o => o._id + ""));
     }
 

package/package.json

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

package/test/entity/delete.js

@@ -260,7 +260,7 @@ describe('Entity Delete', function () {
                 const delete_ids = [db_role["_id"] + ""];
                 const result3 = await role_entity.delete_entity(delete_ids);
                 strictEqual(result3.code, HAS_REF);
-                deepStrictEqual(result3.err, ["user1", "user2"]);
+                deepStrictEqual(result3.err, ["role_delete_seven<-user_entity_delete_seven:user1", "role_delete_seven<-user_entity_delete_seven:user2"]);
 
                 const result4 = await role_entity.delete_entity([db_role2["_id"] + ""]);
                 strictEqual(result4.code, SUCCESS);