hola-server 0.3.7 → 0.3.8

package/core/meta.js

@@ -7,16 +7,23 @@ const meta_manager = {};
  * list: this field can be shown in table list
  * search: this field can be shown in search form
  * update: if is false, in update form, it will be readonly status
+ * delete: delete is only used for ref field, it decide when the ref entity will be deleted, how to handle this entity,no value, will not let the refered entity be deleted, keep: keep this entity(no data consistency), cascade: also delete this entity also,
  * sys: this field is used to control the user can set the value or not. sys field can only be set in the server side(before callback is good place to do this)
  * 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
 */
-const field_attrs = ["name", "type", "required", "ref", "create", "list", "search", "update", "clone", "sys"];
+const field_attrs = ["name", "type", "required", "ref", "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_update", "after_update", "before_delete", "after_delete", "create", "update", "batch_update", "after_batch_update", "delete",
+    "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"];
 
+const DELETE_MODE = Object.freeze({
+    all: ["keep", "cascade"],
+    keep: "keep",
+    cascade: "cascade"
+});
+
 /**
  * Validate the field attributes and keep them correct(also set default value)
  * @param {entity meta} meta 
@@ -44,7 +51,7 @@ const validate_field = (meta, field) => {
         }
 
         if (!ref_meta.ref_label) {
-            throw new Error("meta:" + meta.collection + ",field:" + field.name + " refers an meta:" + field.ref + " without ref_label]");
+            throw new Error("meta:" + meta.collection + ",field:" + field.name + " refers an meta:" + field.ref + " without ref_label");
         }
 
         const ref_by_collections = ref_meta.ref_by_metas.map(m => m.collection);
@@ -53,6 +60,17 @@ const validate_field = (meta, field) => {
         }
     }
 
+    if (field.delete) {
+        if (!field.ref) {
+            throw new Error("meta:" + meta.collection + ",field:" + field.name + " doesn't let define delete in none ref field.");
+        }
+
+        const all_modes = DELETE_MODE.all;
+        if (!all_modes.includes(field.delete)) {
+            throw new Error("meta:" + meta.collection + ",field:" + field.name + " has invalid delete:" + field.delete + ", valid values:" + JSON.stringify(all_modes));
+        }
+    }
+
     const keys = Object.keys(field);
     keys.forEach(key => {
         if (!field_attrs.includes(key)) {
@@ -168,12 +186,15 @@ class EntityMeta {
 
         set_callback(this, "after_read", meta.after_read);
         set_callback(this, "before_create", meta.before_create);
+        set_callback(this, "before_clone", meta.before_clone);
         set_callback(this, "before_update", meta.before_update);
         set_callback(this, "before_delete", meta.before_delete);
         set_callback(this, "after_create", meta.after_create);
+        set_callback(this, "after_clone", meta.after_clone);
         set_callback(this, "after_update", meta.after_update);
         set_callback(this, "after_delete", meta.after_delete);
         set_callback(this, "create", meta.create);
+        set_callback(this, "clone", meta.clone);
         set_callback(this, "update", meta.update);
         set_callback(this, "batch_update", meta.batch_update);
         set_callback(this, "after_batch_update", meta.after_batch_update);
@@ -226,4 +247,4 @@ class EntityMeta {
     }
 }
 
-module.exports = { EntityMeta, validate_all_metas, get_entity_meta, get_all_metas }
+module.exports = { EntityMeta, validate_all_metas, get_entity_meta, get_all_metas, DELETE_MODE }

package/db/entity.js

@@ -2,7 +2,7 @@ const { SUCCESS, ERROR, NO_PARAMS, INVALID_PARAMS, DUPLICATE_KEY, NOT_FOUND, REF
 const { validate_required_fields, has_value } = require('../core/validate');
 const { required_params } = require('../http/params');
 const { convert_type, convert_update_type, get_type } = require('../core/type');
-const { get_entity_meta } = require('../core/meta');
+const { get_entity_meta, DELETE_MODE } = require('../core/meta');
 const { unique, map_array_to_obj } = require('../core/array');
 const { LOG_ENTITY, get_db, oid_query, oid_queries, is_log_debug, is_log_error, log_debug, log_error, get_session_userid } = require('./db');
 
@@ -218,25 +218,7 @@ class Entity {
     * @returns object with code and err
     */
     async create_entity(param_obj) {
-        return this._create_entity(param_obj, this.meta.create_fields);
-    }
-
-    /**
-    * Validate the param object and invoke the logic to clone the entity and sae it to db
-    * @param {param obj from user input} param_obj
-    * @returns object with code and err
-    */
-    async clone_entity(param_obj) {
-        return this._create_entity(param_obj, this.meta.clone_fields);
-    }
-
-    /**
-     * Validate the param object and invoke the logic to save it to db
-     * @param {param obj from user input} param_obj 
-     * @param {fields used to convert value} fields
-     * @returns object with code and err
-     */
-    async _create_entity(param_obj, fields) {
+        const fields = this.meta.create_fields
         const { obj, error_field_names } = convert_type(param_obj, fields);
         if (error_field_names.length > 0) {
             if (is_log_error()) {
@@ -310,6 +292,87 @@ class Entity {
         return { code: SUCCESS };
     }
 
+    /**
+    * Validate the param object and invoke the logic to clone the entity and sae it to db
+    * @param {param obj from user input} param_obj
+    * @returns object with code and err
+    */
+    async clone_entity(param_obj) {
+        const fields = this.meta.clone_fields
+        const { obj, error_field_names } = convert_type(param_obj, fields);
+        if (error_field_names.length > 0) {
+            if (is_log_error()) {
+                log_error(LOG_ENTITY, "error fields:" + JSON.stringify(error_field_names));
+            }
+
+            return { code: INVALID_PARAMS, err: error_field_names };
+        }
+
+        if (this.meta.before_clone) {
+            const { code, err } = await this.meta.before_clone(this, obj);
+            if (err || code != SUCCESS) {
+                if (is_log_error()) {
+                    log_error(LOG_ENTITY, "before_clone error:" + JSON.stringify(err) + ", with code:" + code);
+                }
+                return { code: code, err: err };
+            }
+        }
+
+        const error_required_field_names = validate_required_fields(obj, this.meta.required_field_names);
+        if (error_required_field_names.length > 0) {
+            if (is_log_error()) {
+                log_error(LOG_ENTITY, "error required fields:" + JSON.stringify(error_required_field_names));
+            }
+            return { code: NO_PARAMS, err: error_required_field_names };
+        }
+
+        const entity_count = await this.count_by_primary_keys(obj);
+        if (entity_count > 0) {
+            return { code: DUPLICATE_KEY, err: "entity already exist in db" };
+        }
+
+        if (this.meta.ref_fields) {
+            const { code, err } = await this.validate_ref(obj);
+            if (err || code != SUCCESS) {
+                if (is_log_error()) {
+                    log_error(LOG_ENTITY, "validate_ref error:" + JSON.stringify(err) + ", with code:" + code);
+                }
+                return { code: code, err: err };
+            }
+        }
+
+        if (this.meta.clone) {
+            const { code, err } = await this.meta.clone(this, obj);
+            if (err || code != SUCCESS) {
+                if (is_log_error()) {
+                    log_error(LOG_ENTITY, "clone error:" + JSON.stringify(err) + ", with code:" + code);
+                }
+                return { code: code, err: err };
+            }
+        } else {
+            const db_obj = await this.create(obj);
+            if (!db_obj["_id"]) {
+                if (is_log_error()) {
+                    log_error(LOG_ENTITY, "create error:" + JSON.stringify(err) + ", with code:" + code);
+                }
+                return { code: ERROR, err: "creating record is failed" };
+            }
+        }
+
+        if (this.meta.after_clone) {
+            const { code, err } = await this.meta.after_clone(this, obj);
+            if (err || code != SUCCESS) {
+                if (is_log_error()) {
+                    log_error(LOG_ENTITY, "after_clone error:" + JSON.stringify(err) + ", with code:" + code);
+                }
+                return { code: code, err: err };
+            }
+        }
+
+        return { code: SUCCESS };
+    }
+
+
     /**
      * 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
@@ -569,18 +632,8 @@ class Entity {
             }
         }
 
-        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];
-            const refer_by_entity = new Entity(ref_by_meta);
-            for (let j = 0; j < id_array.length; j++) {
-                const has_refer_by = await refer_by_entity.has_refer_entity(this.meta.collection, id_array[j]);
-                if (has_refer_by) {
-                    has_refer_by_array.push(id_array[j]);
-                }
-            }
-        }
-
+        //check all the ref by array first
+        const has_refer_by_array = await this.check_refer_entity(id_array);
         if (has_refer_by_array.length > 0) {
             if (is_log_error()) {
                 log_error(LOG_ENTITY, "has_refer_by_array:" + JSON.stringify(has_refer_by_array));
@@ -606,6 +659,21 @@ class Entity {
             }
         }
 
+        //delete other ref_by entity based on delete mode
+        for (let i = 0; i < this.meta.ref_by_metas.length; i++) {
+            const ref_by_meta = this.meta.ref_by_metas[i];
+            const ref_fields = ref_by_meta.ref_fields.filter(field => field.ref == this.meta.collection);
+            for (let j = 0; j < ref_fields.length; j++) {
+                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])
+                    }
+                }
+            }
+        }
+
         if (this.meta.after_delete) {
             const { code, err } = await this.meta.after_delete(this, id_array);
             if (err || code != SUCCESS) {
@@ -734,27 +802,72 @@ 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) {
+        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];
+            const refer_by_entity = new Entity(ref_by_meta);
+            const ref_fields = ref_by_meta.ref_fields.filter(field => field.ref == this.meta.collection);
+
+            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 entities = await refer_by_entity.get_refer_entities(this.meta.collection, id_array[j], {});
+                        if (entities && entities.length > 0) {
+                            if (ref_field.delete == DELETE_MODE.cascade) {
+                                const ref_id_array = await refer_by_entity.check_refer_entity(entities.map(o => o._id + ""));
+                                if (ref_id_array && ref_id_array.length > 0) {
+                                    has_refer_by_array.push(id_array[j]);
+                                }
+                            } else {
+                                has_refer_by_array.push(id_array[j]);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return has_refer_by_array;
+    }
+
     /**
      * 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 has_refer_entity(entity_name, entity_id) {
+    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 count = await this.count(query);
-                    if (count > 0) {
-                        return true;
-                    }
+                    const founed = await this.find(query, attr);
+                    array.push(...founed);
                 }
             }
         }
-        return false;
+        return array;
+    }
+
+    /**
+     * delete the ref entity
+     * @param {entity collection} entity_name 
+     * @param {entity object id} entity_id 
+     * @returns 
+     */
+    async delete_refer_entity(entity_name, entity_id) {
+        const entities = await this.get_refer_entities(entity_name, entity_id, {});
+        await this.delete_entity(entities.map(o => o._id + ""));
     }
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hola-server",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "description": "a meta programming framework used to build nodejs restful api",
   "main": "index.js",
   "scripts": {
@@ -23,7 +23,7 @@
   "devDependencies": {
     "chai": "^4.3.6",
     "chai-http": "^4.3.0",
-    "mocha": "^10.0.0"
+    "mocha": "^10.1.0"
   },
   "repository": {
     "type": "git",

package/setting.js

@@ -5,7 +5,7 @@ let settings = {
         key: "AhBWt15WFj8PrMnnZhX8AF1IM4V2x0A3"
     },
     mongo: {
-        url: 'mongodb://localhost/hola',
+        url: 'mongodb://127.0.0.1/hola',
         pool: 10
     },
     log: {

package/test/core/meta.js

@@ -164,6 +164,102 @@ describe('EntityMeta', function () {
             strictEqual(entity_meta2.validate_meta_info(), true);
         });
 
+        it('should success for valid meta info for cascade delete', function () {
+            const entity_meta1 = new EntityMeta({
+                collection: "user11",
+                primary_keys: ["name"],
+                fields: [
+                    { name: "name", type: "string", required: true },
+                    { name: "role", type: "string", ref: "role_meta1", delete: "cascade", required: true },
+                ]
+            });
+
+            const entity_meta2 = new EntityMeta({
+                collection: "role_meta1",
+                primary_keys: ["name"],
+                ref_label: "name",
+                fields: [
+                    { name: "name", type: "string", required: true },
+                ]
+            });
+
+            strictEqual(entity_meta1.validate_meta_info(), true);
+            strictEqual(entity_meta2.validate_meta_info(), true);
+        });
+
+        it('should success for valid meta info for keep delete', function () {
+            const entity_meta1 = new EntityMeta({
+                collection: "user12",
+                primary_keys: ["name"],
+                fields: [
+                    { name: "name", type: "string", required: true },
+                    { name: "role", type: "string", ref: "role_meta2", delete: "keep", required: true },
+                ]
+            });
+
+            const entity_meta2 = new EntityMeta({
+                collection: "role_meta2",
+                primary_keys: ["name"],
+                ref_label: "name",
+                fields: [
+                    { name: "name", type: "string", required: true },
+                ]
+            });
+
+            strictEqual(entity_meta1.validate_meta_info(), true);
+            strictEqual(entity_meta2.validate_meta_info(), true);
+        });
+
+        it('should fails wrong delete value for ref', function () {
+            throws(() => {
+                const entity_meta1 = new EntityMeta({
+                    collection: "user13",
+                    primary_keys: ["name"],
+                    fields: [
+                        { name: "name", type: "string", required: true },
+                        { name: "role", type: "string", ref: "role_meta3", delete: "other", required: true },
+                    ]
+                });
+
+                const entity_meta2 = new EntityMeta({
+                    collection: "role_meta3",
+                    primary_keys: ["name"],
+                    ref_label: "name",
+                    fields: [
+                        { name: "name", type: "string", required: true },
+                    ]
+                });
+                entity_meta1.validate_meta_info();
+                entity_meta2.validate_meta_info();
+            });
+        });
+
+
+        it('should fails delete defined for non-ref field', function () {
+            throws(() => {
+                const entity_meta1 = new EntityMeta({
+                    collection: "user14",
+                    primary_keys: ["name"],
+                    fields: [
+                        { name: "name", type: "string", required: true, delete: "keep" },
+                        { name: "role", type: "string", ref: "role_meta4", required: true },
+                    ]
+                });
+
+                const entity_meta2 = new EntityMeta({
+                    collection: "role_meta4",
+                    primary_keys: ["name"],
+                    ref_label: "name",
+                    fields: [
+                        { name: "name", type: "string", required: true },
+                    ]
+                });
+                entity_meta1.validate_meta_info();
+                entity_meta2.validate_meta_info();
+            });
+        });
+
+
         it('should fails for wrong ref ', function () {
             throws(() => {
                 const entity_meta1 = new EntityMeta({
@@ -208,7 +304,7 @@ describe('EntityMeta', function () {
 
         it('should collection and fields properties set successfully', function () {
             const entity_meta = new EntityMeta({
-                collection: "user11",
+                collection: "user111",
                 primary_keys: ["name"],
                 fields: [
                     { name: "email", type: "string", required: true },
@@ -216,7 +312,7 @@ describe('EntityMeta', function () {
                     { name: "status", type: "string", required: true }
                 ]
             });
-            strictEqual(entity_meta.collection, "user11");
+            strictEqual(entity_meta.collection, "user111");
             strictEqual(entity_meta.fields.length, 3);
             strictEqual(entity_meta.field_names.join(""), ["email", "pwd", "status"].join(""));
         });

package/test/entity/delete.js

@@ -270,6 +270,210 @@ describe('Entity Delete', function () {
             });
         });
 
+        describe('delete entity with ref and keep delete fields', function () {
+            const user_meta = new EntityMeta({
+                creatable: true,
+                readable: true,
+                updatable: true,
+                deleteable: true,
+                collection: "user_entity_delete_eight",
+                primary_keys: ["name"],
+                ref_label: "name",
+                fields: [
+                    { name: "name", required: true },
+                    { name: "age", type: "uint" },
+                    { name: "role", type: "string", ref: "role_delete_eight", delete: "keep", required: true },
+                ]
+            });
+
+            const role_meta = new EntityMeta({
+                creatable: true,
+                readable: true,
+                updatable: true,
+                deleteable: true,
+                collection: "role_delete_eight",
+                primary_keys: ["name"],
+                ref_label: "name",
+                fields: [
+                    { name: "name", required: true },
+                    { name: "desc", type: "string" }
+                ]
+            });
+
+            const log_meta = new EntityMeta({
+                creatable: true,
+                readable: true,
+                updatable: true,
+                deleteable: true,
+                collection: "log_one",
+                primary_keys: ["name"],
+                ref_label: "name",
+                fields: [
+                    { name: "name", required: true },
+                    { name: "user", type: "string", ref: "user_entity_delete_eight", delete: "cascade", required: true },
+                ]
+            });
+
+            user_meta.validate_meta_info();
+            role_meta.validate_meta_info();
+            log_meta.validate_meta_info();
+
+            const user_entity = new Entity(user_meta);
+            const role_entity = new Entity(role_meta);
+            const log_entity = new Entity(log_meta);
+
+            it('should delete user successfully with role', async function () {
+                await user_entity.delete({});
+                await role_entity.delete({});
+                await log_entity.delete({});
+                await role_entity.create({ "name": "role1" });
+                await role_entity.create({ "name": "role2", desc: "role 2" });
+                const db_role = await role_entity.find_one(user_entity.primary_key_query({ "name": "role1" }));
+
+                const user = { "name": "user1", age: "10", role: "role1" };
+                const { code, err } = await user_entity.create_entity(user);
+                const query = user_entity.primary_key_query(user);
+                const db_user = await user_entity.find_one(query);
+                strictEqual(code, SUCCESS);
+                strictEqual(err, undefined);
+                strictEqual(db_user.role, db_role["_id"] + "");
+
+                const user2 = { "name": "user2", age: "20", role: db_role["_id"] + "" };
+                const result = await user_entity.create_entity(user2);
+                const query2 = user_entity.primary_key_query(user2);
+                const db_user2 = await user_entity.find_one(query2);
+                strictEqual(result.code, SUCCESS);
+                strictEqual(result.err, undefined);
+                strictEqual(db_user2.role, db_role["_id"] + "");
+
+                const log1 = { "name": "log1", user: db_user2["_id"] + "" };
+                const resultlog = await log_entity.create_entity(log1);
+                const db_log = await log_entity.find_one(log_entity.primary_key_query(log1));
+                strictEqual(resultlog.code, SUCCESS);
+                strictEqual(resultlog.err, undefined);
+                strictEqual(db_log.user, db_user2["_id"] + "");
+
+                const delete_ids = [db_role["_id"] + ""];
+                const result3 = await role_entity.delete_entity(delete_ids);
+                strictEqual(result3.code, SUCCESS);
+                deepStrictEqual(result3.err, undefined);
+
+                strictEqual(await user_entity.count({}), 2);
+                strictEqual(await role_entity.count({}), 1);
+                strictEqual(await log_entity.count({}), 1);
+
+                const result4 = await user_entity.delete_entity([db_user2["_id"] + ""]);
+                strictEqual(result4.code, SUCCESS);
+                deepStrictEqual(result4.err, undefined);
+
+                strictEqual(await user_entity.count({}), 1);
+                strictEqual(await role_entity.count({}), 1);
+                strictEqual(await log_entity.count({}), 0);
+
+                await user_entity.delete({});
+                await role_entity.delete({});
+                await log_entity.delete({});
+            });
+        });
+
+
+        describe('delete entity with ref and cascade delete fields', function () {
+            const user_meta = new EntityMeta({
+                creatable: true,
+                readable: true,
+                updatable: true,
+                deleteable: true,
+                collection: "user_entity_delete_nine",
+                primary_keys: ["name"],
+                ref_label: "name",
+                fields: [
+                    { name: "name", required: true },
+                    { name: "age", type: "uint" },
+                    { name: "role", type: "string", ref: "role_delete_nine", delete: "cascade", required: true },
+                ]
+            });
+
+            const role_meta = new EntityMeta({
+                creatable: true,
+                readable: true,
+                updatable: true,
+                deleteable: true,
+                collection: "role_delete_nine",
+                primary_keys: ["name"],
+                ref_label: "name",
+                fields: [
+                    { name: "name", required: true },
+                    { name: "desc", type: "string" }
+                ]
+            });
+
+            const log_meta = new EntityMeta({
+                creatable: true,
+                readable: true,
+                updatable: true,
+                deleteable: true,
+                collection: "log_nine",
+                primary_keys: ["name"],
+                ref_label: "name",
+                fields: [
+                    { name: "name", required: true },
+                    { name: "user", type: "string", ref: "user_entity_delete_nine", delete: "cascade", required: true },
+                ]
+            });
+
+            user_meta.validate_meta_info();
+            role_meta.validate_meta_info();
+            log_meta.validate_meta_info();
+
+            const user_entity = new Entity(user_meta);
+            const role_entity = new Entity(role_meta);
+            const log_entity = new Entity(log_meta);
+
+            it('should delete user successfully with role', async function () {
+                await user_entity.delete({});
+                await role_entity.delete({});
+                await log_entity.delete({});
+                await role_entity.create({ "name": "role1" });
+                await role_entity.create({ "name": "role2", desc: "role 2" });
+                const db_role = await role_entity.find_one(user_entity.primary_key_query({ "name": "role1" }));
+
+                const user = { "name": "user1", age: "10", role: "role1" };
+                const { code, err } = await user_entity.create_entity(user);
+                const query = user_entity.primary_key_query(user);
+                const db_user = await user_entity.find_one(query);
+                strictEqual(code, SUCCESS);
+                strictEqual(err, undefined);
+                strictEqual(db_user.role, db_role["_id"] + "");
+
+                const user2 = { "name": "user2", age: "20", role: db_role["_id"] + "" };
+                const result = await user_entity.create_entity(user2);
+                const query2 = user_entity.primary_key_query(user2);
+                const db_user2 = await user_entity.find_one(query2);
+                strictEqual(result.code, SUCCESS);
+                strictEqual(result.err, undefined);
+                strictEqual(db_user2.role, db_role["_id"] + "");
+
+                const log1 = { "name": "log1", user: db_user2["_id"] + "" };
+                const resultlog = await log_entity.create_entity(log1);
+                const db_log = await log_entity.find_one(log_entity.primary_key_query(log1));
+                strictEqual(resultlog.code, SUCCESS);
+                strictEqual(resultlog.err, undefined);
+                strictEqual(db_log.user, db_user2["_id"] + "");
+
+                const delete_ids = [db_role["_id"] + ""];
+                const result3 = await role_entity.delete_entity(delete_ids);
+                strictEqual(result3.code, SUCCESS);
+                deepStrictEqual(result3.err, undefined);
+
+                strictEqual(await user_entity.count({}), 0);
+                strictEqual(await role_entity.count({}), 1);
+                strictEqual(await log_entity.count({}), 0);
+
+                await user_entity.delete({});
+                await role_entity.delete({});
+                await log_entity.delete({});
+            });
+        });
     });
 }
 );