hola-server 1.0.11 → 2.0.1

package/test/entity/delete-mixed.js

@@ -0,0 +1,156 @@
+const { strictEqual } = require("assert");
+const { Entity } = require("../../db/entity");
+const { EntityMeta } = require("../../core/meta");
+const { SUCCESS } = require("../../http/code");
+
+// Parent with mixed keep/cascade references
+const role_mix_meta = new EntityMeta({
+    creatable: true,
+    readable: true,
+    updatable: true,
+    deleteable: true,
+    collection: "role_delete_mix",
+    primary_keys: ["name"],
+    ref_label: "name",
+    fields: [
+        { name: "name", required: true }
+    ]
+});
+
+const user_keep_meta = new EntityMeta({
+    creatable: true,
+    readable: true,
+    updatable: true,
+    deleteable: true,
+    collection: "user_delete_keep",
+    primary_keys: ["name"],
+    fields: [
+        { name: "name", required: true },
+        { name: "role", type: "string", ref: "role_delete_mix", delete: "keep", required: true }
+    ]
+});
+
+const audit_cascade_meta = new EntityMeta({
+    creatable: true,
+    readable: true,
+    updatable: true,
+    deleteable: true,
+    collection: "audit_delete_cascade",
+    primary_keys: ["name"],
+    fields: [
+        { name: "name", required: true },
+        { name: "role", type: "string", ref: "role_delete_mix", delete: "cascade", required: true }
+    ]
+});
+
+role_mix_meta.validate_meta_info();
+user_keep_meta.validate_meta_info();
+audit_cascade_meta.validate_meta_info();
+
+const role_mix_entity = new Entity(role_mix_meta);
+const user_keep_entity = new Entity(user_keep_meta);
+const audit_cascade_entity = new Entity(audit_cascade_meta);
+
+// Parent with array ref cascade chain
+const role_array_meta = new EntityMeta({
+    creatable: true,
+    readable: true,
+    updatable: true,
+    deleteable: true,
+    collection: "role_delete_array",
+    primary_keys: ["name"],
+    ref_label: "name",
+    fields: [
+        { name: "name", required: true }
+    ]
+});
+
+const user_array_meta = new EntityMeta({
+    creatable: true,
+    readable: true,
+    updatable: true,
+    deleteable: true,
+    collection: "user_delete_array",
+    primary_keys: ["name"],
+    ref_label: "name",
+    fields: [
+        { name: "name", required: true },
+        { name: "roles", type: "array", ref: "role_delete_array", delete: "cascade", required: true }
+    ]
+});
+
+const audit_array_meta = new EntityMeta({
+    creatable: true,
+    readable: true,
+    updatable: true,
+    deleteable: true,
+    collection: "audit_delete_array",
+    primary_keys: ["name"],
+    fields: [
+        { name: "name", required: true },
+        { name: "user", type: "string", ref: "user_delete_array", delete: "cascade", required: true }
+    ]
+});
+
+role_array_meta.validate_meta_info();
+user_array_meta.validate_meta_info();
+audit_array_meta.validate_meta_info();
+
+const role_array_entity = new Entity(role_array_meta);
+const user_array_entity = new Entity(user_array_meta);
+const audit_array_entity = new Entity(audit_array_meta);
+
+describe("Entity delete cascade/keep edges", function () {
+    beforeEach(async function () {
+        await role_mix_entity.delete({});
+        await user_keep_entity.delete({});
+        await audit_cascade_entity.delete({});
+        await role_array_entity.delete({});
+        await user_array_entity.delete({});
+        await audit_array_entity.delete({});
+    });
+
+    after(async function () {
+        await role_mix_entity.delete({});
+        await user_keep_entity.delete({});
+        await audit_cascade_entity.delete({});
+        await role_array_entity.delete({});
+        await user_array_entity.delete({});
+        await audit_array_entity.delete({});
+    });
+
+    it("should cascade deletions while keeping keep-referenced entities", async function () {
+        await role_mix_entity.create_entity({ name: "role1" });
+        const role = await role_mix_entity.find_one({ name: "role1" });
+
+        const { code: uCode } = await user_keep_entity.create_entity({ name: "u1", role: "role1" });
+        strictEqual(uCode, SUCCESS);
+        const { code: aCode } = await audit_cascade_entity.create_entity({ name: "a1", role: "role1" });
+        strictEqual(aCode, SUCCESS);
+
+        const result = await role_mix_entity.delete_entity([role._id + ""]);
+        strictEqual(result.code, SUCCESS);
+        strictEqual(await role_mix_entity.count({}), 0);
+        strictEqual(await user_keep_entity.count({}), 1);
+        strictEqual(await audit_cascade_entity.count({}), 0);
+    });
+
+    it("should cascade through array refs and downstream cascades", async function () {
+        await role_array_entity.create_entity({ name: "r1" });
+        await role_array_entity.create_entity({ name: "r2" });
+        const role1 = await role_array_entity.find_one({ name: "r1" });
+
+        const { code: uCode } = await user_array_entity.create_entity({ name: "u1", roles: ["r1", "r2"] });
+        strictEqual(uCode, SUCCESS);
+        const user = await user_array_entity.find_one({ name: "u1" });
+        const { code: aCode } = await audit_array_entity.create_entity({ name: "a1", user: user._id + "" });
+        strictEqual(aCode, SUCCESS);
+
+        const result = await role_array_entity.delete_entity([role1._id + ""]);
+        strictEqual(result.code, SUCCESS);
+
+        strictEqual(await role_array_entity.count({}), 1); // r2 remains
+        strictEqual(await user_array_entity.count({}), 0); // u1 cascaded
+        strictEqual(await audit_array_entity.count({}), 0); // a1 cascaded via user deletion
+    });
+});

package/test/entity/ref-filter.js

@@ -0,0 +1,63 @@
+const { strictEqual } = require("assert");
+const { Entity } = require("../../db/entity");
+const { EntityMeta } = require("../../core/meta");
+const { SUCCESS, REF_NOT_FOUND } = require("../../http/code");
+
+const role_meta = new EntityMeta({
+    collection: "role_filter",
+    primary_keys: ["name"],
+    ref_label: "name",
+    fields: [
+        { name: "name", type: "string", required: true },
+        { name: "status", type: "boolean", required: true }
+    ],
+    ref_filter: { status: true }
+});
+role_meta.validate_meta_info();
+const role_entity = new Entity(role_meta);
+
+const user_meta = new EntityMeta({
+    collection: "user_filter",
+    primary_keys: ["name"],
+    fields: [
+        { name: "name", type: "string", required: true },
+        { name: "role", type: "string", ref: "role_filter", required: true }
+    ]
+});
+user_meta.validate_meta_info();
+const user_entity = new Entity(user_meta);
+
+describe("Entity ref_filter", function () {
+    beforeEach(async function () {
+        await role_entity.delete({});
+        await user_entity.delete({});
+    });
+
+    after(async function () {
+        await role_entity.delete({});
+        await user_entity.delete({});
+    });
+
+    it("should reject ref values filtered out by ref_filter", async function () {
+        await role_entity.create_entity({ name: "active", status: true });
+        await role_entity.create_entity({ name: "inactive", status: false });
+
+        const { code, err } = await user_entity.create_entity({ name: "u1", role: "inactive" });
+        strictEqual(code, REF_NOT_FOUND);
+        strictEqual(err[0], "role");
+
+        const { code: ok } = await user_entity.create_entity({ name: "u2", role: "active" });
+        strictEqual(ok, SUCCESS);
+    });
+
+    it("find_by_ref_value should obey default ref_filter", async function () {
+        await role_entity.create_entity({ name: "active", status: true });
+        await role_entity.create_entity({ name: "inactive", status: false });
+
+        const active = await role_entity.find_by_ref_value("active", { _id: 1 });
+        strictEqual(active.length, 1);
+
+        const inactive = await role_entity.find_by_ref_value("inactive", { _id: 1 });
+        strictEqual(inactive.length, 0);
+    });
+});

package/tool/gen_i18n.js

@@ -1,30 +1,64 @@
+/**
+ * @fileoverview I18n JSON file generation from entity metadata.
+ * @module tool/gen_i18n
+ */
+
 const fs = require('fs');
 const { get_all_metas, get_entity_meta } = require('../core/meta');
 
+/**
+ * Capitalize first letter of string.
+ * @param {string} s - String to capitalize.
+ * @returns {string} Capitalized string.
+ */
 const capitalize = (s) => {
-    if (typeof s !== 'string') return ''
-    return s.charAt(0).toUpperCase() + s.slice(1)
-}
+    if (typeof s !== 'string') return '';
+    return s.charAt(0).toUpperCase() + s.slice(1);
+};
 
-const gen_i18n = (file_path, keep_hint) => {
-    let json_file = fs.readFileSync(file_path);
-    let json = JSON.parse(json_file);
+/**
+ * Process entity metadata and add to i18n JSON.
+ * @param {Object} json - I18n JSON object.
+ * @param {Object} meta - Entity metadata.
+ * @param {boolean} keep_hint - Whether to generate hint fields.
+ */
+const process_entity_i18n = (json, meta, keep_hint) => {
+    // Initialize collection object
+    json[meta.collection] = json[meta.collection] || {};
+    json[meta.collection]["_label"] = json[meta.collection]["_label"] || capitalize(meta.collection);
 
-    const metas = get_all_metas();
-    for (let i = 0; i < metas.length; i++) {
-        const meta = get_entity_meta(metas[i]);
-        json[meta.collection] || (json[meta.collection] = {});
-        json[meta.collection]["_label"] || (json[meta.collection]["_label"] = capitalize(meta.collection));
-        const fields = meta.fields.filter(f => f.sys != true);
-        for (let j = 0; j < fields.length; j++) {
-            const field = fields[j];
-            json[meta.collection][field.name] || (json[meta.collection][field.name] = capitalize(field.name));
-            if (keep_hint) {
-                json[meta.collection][field.name + "_hint"] || (json[meta.collection][field.name + "_hint"] = "")
-            }
+    // Process non-system fields
+    const fields = meta.fields.filter((f) => f.sys !== true);
+    fields.forEach((field) => {
+        json[meta.collection][field.name] = json[meta.collection][field.name] || capitalize(field.name);
+
+        if (keep_hint) {
+            const hint_key = field.name + "_hint";
+            json[meta.collection][hint_key] = json[meta.collection][hint_key] || "";
         }
-    }
+    });
+};
+
+/**
+ * Generate i18n JSON file from entity metadata.
+ * Reads existing file, merges with entity field names, and writes back.
+ * @param {string} file_path - Path to i18n JSON file.
+ * @param {boolean} [keep_hint=false] - Whether to generate hint fields for each field.
+ */
+const gen_i18n = (file_path, keep_hint = false) => {
+    // Read existing JSON file
+    const json_file = fs.readFileSync(file_path, 'utf8');
+    const json = JSON.parse(json_file);
+
+    // Process all entity metadata
+    const metas = get_all_metas();
+    metas.forEach((meta_name) => {
+        const meta = get_entity_meta(meta_name);
+        process_entity_i18n(json, meta, keep_hint);
+    });
+
+    // Write updated JSON
     fs.writeFileSync(file_path, JSON.stringify(json, null, 2));
-}
+};
 
-module.exports = { gen_i18n }
+module.exports = { gen_i18n };

package/test/crud/router.js

@@ -1,99 +0,0 @@
-const chai = require('chai');
-const chai_http = require('chai-http');
-const { strictEqual, deepStrictEqual } = require('assert');
-
-const { init_express_server } = require('../../http/express');
-const { get_entity_meta } = require('../../core/meta');
-const { Entity } = require('../../db/entity');
-const { SUCCESS } = require('../../http/code');
-
-const server = init_express_server(__dirname + "/../");
-chai.use(chai_http);
-
-describe('user router controller crud testing', () => {
-    const user_entity = new Entity(get_entity_meta("user"));
-    const role_entity = new Entity(get_entity_meta("role"));
-
-    beforeEach((done) => {
-        user_entity.delete({}).then(_ => {
-            role_entity.delete({}).then(_ => {
-                done();
-            });
-        });
-    });
-
-    describe('/POST create user', () => {
-
-        it('it should POST a user successfully with all the valid values', async (done) => {
-            await role_entity.create_entity({ "name": "admin", desc: "admin role" });
-            await role_entity.create_entity({ "name": "user", desc: "user role" });
-            const role_count = (await role_entity.find({})).length;
-            strictEqual(role_count, 2);
-
-            const user = {
-                name: "hery",
-                email: "hery@easyserver.com",
-                role: "admin,user",
-                age: "10",
-                status: "true"
-            }
-            chai.request(server)
-                .post('/user/create')
-                .send(user)
-                .end(async (err, res) => {
-                    strictEqual(res.status, 200);
-                    strictEqual(res.body.code, SUCCESS);
-
-                    const db_user = await user_entity.find_one(user_entity.primary_key_query({ "name": "hery" }));
-                    const db_roles = await role_entity.find({});
-                    strictEqual(db_user.name, "hery");
-                    strictEqual(db_user.age, 10);
-                    deepStrictEqual(db_user.role, db_roles.map(r => r["_id"] + ""));
-                    done();
-                });
-        });
-
-        it('it should read the entity success', async (done) => {
-            await role_entity.create_entity({ "name": "admin", desc: "admin role" });
-            await role_entity.create_entity({ "name": "user", desc: "user role" });
-            await user_entity.create_entity({
-                name: "hery",
-                email: "hery@easyserver.com",
-                role: "admin,user",
-                age: "10",
-                status: "true"
-            });
-
-            const db_user = await user_entity.find_one(user_entity.primary_key_query({ "name": "hery" }));
-
-            chai.request(server)
-                .post('/user/read')
-                .send({ "_id": db_user._id + "", "attr_names": "name,age" })
-                .end(async (err, res) => {
-                    strictEqual(res.status, 200);
-                    strictEqual(res.body.err, undefined);
-                    strictEqual(res.body.code, SUCCESS);
-
-                    const user = res.body.data;
-                    strictEqual(user.name, "hery");
-                    strictEqual(user.age, 10);
-                    strictEqual(user.email, undefined);
-                    strictEqual(user.status, undefined);
-
-                    done();
-                });
-        });
-
-        it('it should get entity fields', async (done) => {
-            chai.request(server)
-                .get('/user/meta')
-                .end(async (err, res) => {
-                    strictEqual(res.status, 200);
-                    strictEqual(res.body.code, SUCCESS);
-                    strictEqual(res.body.data.fields.length, 5);
-
-                    done();
-                });
-        });
-    });
-});

package/test/router/user.js

@@ -1,17 +0,0 @@
-const { init_router } = require('../../http/router')
-
-module.exports = init_router({
-    creatable: true,
-    readable: true,
-    updatable: true,
-    deleteable: true,
-    collection: "user",
-    primary_keys: ["name"],
-    fields: [
-        { name: "name", required: true },
-        { name: "email", type: "string" },
-        { name: "age", type: "uint" },
-        { name: "role", type: "array", ref: "role", required: true },
-        { name: "status", type: "boolean", sys: true }
-    ]
-});