mushroom-cli 1.2.0-alpha.7.1 → 1.2.0-alpha.9

package/gen/gen-api-docs-v1.js

@@ -0,0 +1,125 @@
+const fs = require("fs");
+const open = require("open");
+const jsdom = require("jsdom");
+const { JSDOM } = jsdom;
+const common = require("../common.js");
+
+function processGenDocs(aliasProject, entities, source, html, args, projectName, alias) {
+    console.log('Received html');
+    console.log("Parsing html");
+
+    const roles = aliasProject.allowRoles.includes("*") ? source.roles : source.roles?.filter(r => aliasProject.allowRoles.includes(r.name));
+    
+    html = html.replace(/^\uFEFF/, '');
+    html = html.replace(/<script src="([^"]+)" data-mt-cond='\{"lazy-load": 1\}'><\/script>/g, (scriptTag, src) => `<script data-mt-cond='{"x": 1}'>${fs.readFileSync(__dirname + "/../docs/" + src).toString()}</script>`);
+    html = html.replace("</body>", `<script data-mt-cond='{"x": 1}'>
+    window.data.name = ${JSON.stringify(source.name)};
+    window.data.description = ${JSON.stringify(source.description)};
+    window.data.rootUrl = ${JSON.stringify(common.getRootUrl(source))};
+    window.data.environmentVariables = ${JSON.stringify(source.environmentVariables)};
+    window.data.roles = ${JSON.stringify(roles)};
+    window.data.entities = ${JSON.stringify(entities)};
+    window.data.features = ${JSON.stringify(aliasProject.features)};
+    try {
+        console.info("MUSHROOM-CLI: START");
+        window.generateDocument();
+        console.info("MUSHROOM-CLI: FINISH");
+    }
+    catch (e) {
+        console.info("MUSHROOM-CLI: FAIL", e);
+    }
+    window.close();
+</script></body>`);
+
+    return new Promise((resolve, reject) => {
+        const virtualConsole = new jsdom.VirtualConsole();
+        virtualConsole.on("info", function(msg, err) {
+            if (typeof msg != "string") return;
+
+            if (msg.indexOf("MUSHROOM-CLI:") === 0) {
+                console.log("GenDocEngine:" + msg.substring("MUSHROOM-CLI:".length));
+            }
+
+            if (msg === "MUSHROOM-CLI: FAIL"){
+                dom = null;
+                reject(err);
+                return;
+            }
+
+            if (msg !== "MUSHROOM-CLI: FINISH") return;
+
+            const code = "<!DOCTYPE html>" + dom.window.document.documentElement.outerHTML;
+
+            dom = null;
+
+            if (args[3] === "tmp") {
+                const htmlFilePath = aliasProject.output + "_tmp.html";
+                console.log(`Writing to ${htmlFilePath}`);
+                fs.writeFile(htmlFilePath, code, err => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+
+                    console.log("Opening file " + htmlFilePath);
+                    open(htmlFilePath).then(() => { 
+                        setTimeout(() => {
+                            fs.unlink(htmlFilePath, ex => {
+                                if (ex)
+                                    console.error("Unable to delete file " + htmlFilePath)
+                            });
+                        }, 1000);
+                    }).catch(() => console.error("Unable to open " + htmlFilePath));
+                    resolve();
+                });
+                return;
+            }
+        
+            common.ensureFolder(aliasProject.output);
+        
+            console.log(`Writing to ${aliasProject.output}`);
+            fs.writeFile(aliasProject.output, code, err => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                console.log(`Generated API docs for ${projectName}@${alias} to ${aliasProject.output}`);
+                resolve();
+            });
+        });
+
+        let dom = new JSDOM(html, { 
+            runScripts: "dangerously",
+            resources: "usable",
+            virtualConsole: virtualConsole
+        });
+        console.log('Rendering API document');
+    });
+}
+
+async function genDocs(args, projectName, project, alias, source) {
+    const aliasProject = ((project.docs || {}).alias || {})[alias];
+
+    if (!aliasProject) {
+        throw new Error(`Not found gen docs configuration. Please run 'npx mushroom-cli config ${projectName} gen docs OUTPUT_FILE.html${alias === "default" ? "" : " alias " + alias}' first`);
+    }
+
+    console.log("Use GenDocEngine v1");
+
+    const entities = common.getEntities(source, aliasProject.allowRoles);
+
+    if (Array.isArray(aliasProject.entities)) {
+        for (const entityName in entities) {
+            if (Object.hasOwnProperty.call(entities, entityName)) {
+                if (aliasProject.entities.every(re => !new RegExp(re).test(entityName))){
+                    delete entities[entityName];
+                }
+            }
+        }
+    }
+
+    const html = fs.readFileSync(__dirname + "/../docs/docs.html").toString();
+    await processGenDocs(aliasProject, entities, source, html, args, projectName, alias);
+}
+
+module.exports = genDocs;

package/gen/gen-api-docs.js

@@ -1,101 +1,226 @@
 const fs = require("fs");
 const open = require("open");
-const fetch = require('node-fetch');
-const jsdom = require("jsdom");
-const { JSDOM } = jsdom;
 const common = require("../common.js");
+const minify = require("minify");
+const path = require("path");
 
-function processGenDocs(aliasProject, entities, source, html, args, projectName, alias) {
-    console.log('Received html');
-    console.log("Parsing html");
-
-    const roles = aliasProject.allowRoles.includes("*") ? source.roles : source.roles?.filter(r => aliasProject.allowRoles.includes(r.name));
-    
-    html = html.replace(/^\uFEFF/, '');
-    html = html.replace(/<script src="([^"]+)" data-mt-cond='\{"lazy-load": 1\}'><\/script>/g, (scriptTag, src) => `<script data-mt-cond='{"x": 1}'>${fs.readFileSync(__dirname + "/../docs/" + src).toString()}</script>`);
-    html = html.replace("</body>", `<script data-mt-cond='{"x": 1}'>
-    window.data.name = ${JSON.stringify(source.name)};
-    window.data.description = ${JSON.stringify(source.description)};
-    window.data.rootUrl = ${JSON.stringify(common.getRootUrl(source))};
-    window.data.environmentVariables = ${JSON.stringify(source.environmentVariables)};
-    window.data.roles = ${JSON.stringify(roles)};
-    window.data.entities = ${JSON.stringify(entities)};
-    window.data.features = ${JSON.stringify(aliasProject.features)};
-    try {
-        console.info("MUSHROOM-CLI: START");
-        window.generateDocument();
-        console.info("MUSHROOM-CLI: FINISH");
+function reserveWhitelist(obj, whitelist) {
+    if (obj === null && typeof obj !== "object") return null;
+    for (let m in obj) {
+        if (!whitelist.includes(m)) delete obj[m];
     }
-    catch (e) {
-        console.info("MUSHROOM-CLI: FAIL", e);
-    }
-    window.close();
-</script></body>`);
+    return obj;
+}
 
-    return new Promise((resolve, reject) => {
-        const virtualConsole = new jsdom.VirtualConsole();
-        virtualConsole.on("info", function(msg, err) {
-            if (typeof msg != "string") return;
+const environmentVariableWhitelist = ["type", "description"];
+function filterEnvironmentVariables(environmentVariables) {
+    Object.values(environmentVariables).forEach(env => reserveWhitelist(env, environmentVariableWhitelist));
+}
 
-            if (msg.indexOf("MUSHROOM-CLI:") === 0) {
-                console.log("GenDocEngine:" + msg.substring("MUSHROOM-CLI:".length));
-            }
+const entityWhitelist = ["name", "description", "actions", "views", "features", "fields"];
+const actionWhitelist = ["grant", "deny", "matches", "description", "exclude"];
+const findByIdWhitelist = [ ...actionWhitelist, "returnableFields", "defaultFields"];
+const findManyWhitelist = [ ...findByIdWhitelist, "allowFilteringFields", "requiredFilteringFields", "allowSortings", "defaultSortings", "pagingType", "maxPageSize", "pageSize", "includeTotal", "cache"];
+const generalWhitelist = [ ...actionWhitelist, "codeHint" ];
+const entityFeatureWhitelist = ["vn_text"];
+const vnTextWhitelist = ["fields", "channels"];
+const vnTextChannelWhitelist = ["fields", "name"];
+const actionCodeHintWhitelist = ["delegator"];
+const actionCodeHintDelegatorWhitelist = ["param", "requestBody"];
+const fieldsOnlyWhitelist = ["fields"];
+const viewWhitelist = [ "grant", "deny", "description", "parameters", "emptyResult", "codeHint"]
+const viewCodeHintWhitelist = ["output"];
 
-            if (msg === "MUSHROOM-CLI: FAIL"){
-                dom = null;
-                reject(err);
-                return;
+function filterEntities(entities) {
+    Object.values(entities).forEach(entity => {
+        filterEntityFields(entity);
+        if (!reserveWhitelist(entity, entityWhitelist)) return;
+        Object.keys(entity.actions).forEach(actionName => {
+            const actions = entity.actions[actionName];            
+            switch (actionName) {
+                case "findMany":
+                    actions.forEach(action => reserveWhitelist(action, findManyWhitelist));
+                    break;
+                case "findById":
+                    actions.forEach(action => reserveWhitelist(action, findByIdWhitelist));
+                    break;
+                case "createOne":
+                case "createMany":
+                case "updateOne":
+                case "updateMany":
+                case "updatePartially":
+                case "deleteOne":
+                case "deleteMany":
+                    actions.forEach(action => reserveWhitelist(action, actionWhitelist));
+                    break;
+                default:
+                    actions.forEach(action => {
+                        reserveWhitelist(action, generalWhitelist);
+                        if (!reserveWhitelist(action.codeHint, actionCodeHintWhitelist)) return;
+                        if (!reserveWhitelist(action.codeHint.delegator, actionCodeHintDelegatorWhitelist)) return;
+                        reserveWhitelist(action.codeHint.delegator.param, fieldsOnlyWhitelist)
+                        reserveWhitelist(action.codeHint.delegator.requestBody, fieldsOnlyWhitelist)
+                    });
+                    break;
             }
 
-            if (msg !== "MUSHROOM-CLI: FINISH") return;
-
-            const code = "<!DOCTYPE html>" + dom.window.document.documentElement.outerHTML;
-
-            dom = null;
-
-            if (args[3] === "tmp") {
-                const htmlFilePath = aliasProject.output + "_tmp.html";
-                console.log(`Writing to ${htmlFilePath}`);
-                fs.writeFile(htmlFilePath, code, err => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-
-                    console.log("Opening file " + htmlFilePath);
-                    open(htmlFilePath).then(() => { 
-                        setTimeout(() => {
-                            fs.unlink(htmlFilePath, ex => {
-                                if (ex)
-                                    console.error("Unable to delete file " + htmlFilePath)
-                            });
-                        }, 1000);
-                    }).catch(() => console.error("Unable to open " + htmlFilePath));
-                    resolve();
-                });
-                return;
-            }
-        
-            common.ensureFolder(aliasProject.output);
-        
-            console.log(`Writing to ${aliasProject.output}`);
-            fs.writeFile(aliasProject.output, code, err => {
-                if (err) {
-                    reject(err);
-                    return;
-                }
-                console.log(`Generated API docs for ${projectName}@${alias} to ${aliasProject.output}`);
-                resolve();
-            });
         });
+        Object.keys(entity.views).forEach(viewName => {
+            const views = entity.views[viewName];
+            views.forEach(view => {
+                reserveWhitelist(view, viewWhitelist);
+                if (!reserveWhitelist(view.codeHint, viewCodeHintWhitelist)) return;
+                reserveWhitelist(view.codeHint.output, fieldsOnlyWhitelist)
+            });
+        })
+        if (!reserveWhitelist(entity.features, entityFeatureWhitelist)) return;
+        if (!reserveWhitelist(entity.features.vn_text, vnTextWhitelist)) return;
+        entity.features.vn_text.channels?.forEach(channel => reserveWhitelist(channel, vnTextChannelWhitelist));
+    });
+}
 
-        let dom = new JSDOM(html, { 
-            runScripts: "dangerously",
-            resources: "usable",
-            virtualConsole: virtualConsole
-        });
-        console.log('Rendering API document');
+function flattenFields(fields, dict, prefix) {
+    dict ??= {};
+    prefix ??= "";
+
+    for (let m in fields) {
+        const path = prefix ? prefix + "." + m : m;
+        dict[path] = false;
+        const config = fields[m];
+        if (config.type == "object") {
+            flattenFields(config.fields ?? {}, dict, path);
+        }
+        else if (config.type == "array" && config.items && config.items.type == "object") {
+            flattenFields(config.items.fields ?? {}, dict, path);
+        }
+    }
+    
+    return dict;
+}
+
+function removeDisallowedFields(fields, dict) {
+    const allowFields = Object.keys(dict);
+    if (!allowFields.length) return;
+    reserveWhitelist(fields, allowFields);
+    for (let m in fields) {
+        const config = fields[m];
+        if (config.type == "object") {
+            removeDisallowedFields(config.fields ?? {}, dict[m]);
+        }
+        else if (config.type == "array" && config.items && config.items.type == "object") {
+            removeDisallowedFields(config.items.fields ?? {}, dict[m]);
+        }
+    }
+}
+
+function markAllowFields(allowFields, dict) {
+    if (!Array.isArray(allowFields)) return;
+    allowFields.forEach(field => dict[field] = true);
+}
+
+function markIncludedFields(excludedFields, dict) {
+    if (!Array.isArray(excludedFields)) return;
+    for (let m in dict) {
+        if (!dict[m] && !excludedFields.includes(m)) dict[m] = true;
+    }
+}
+
+function filterEntityFields(entity) {
+    const dict = flattenFields(entity.fields);
+    Object.keys(entity.actions).forEach(actionName => {
+        const actions = entity.actions[actionName];            
+        switch (actionName) {
+            case "findMany":
+            case "findById":
+                actions.forEach(action => {
+                    markAllowFields(action.returnableFields, dict);
+                    markAllowFields(action.defaultFields, dict);
+                });
+                break;
+            case "createOne":
+            case "createMany":
+            case "updateOne":
+            case "updateMany":
+            case "updatePartially":
+                actions.forEach(action => markIncludedFields(action.exclude, dict));
+                break;
+        }
     });
+    const allowFields = Object.keys(dict).filter(m => dict[m]);
+    [...allowFields].forEach(shortField => {
+        shortField += ".";
+        allowFields.map((longerField, i) => longerField.includes(shortField) ? i : -1)
+            .filter(i => i !== -1)
+            .reverse()
+            .forEach(i => allowFields.splice(i, 1));
+    });
+    const whitelist = { };
+    allowFields.forEach(fields => {
+        let obj = whitelist;
+        fields.split('.').forEach(name => {
+            let child = obj[name];
+            if (!child) child = obj[name] = {};
+            obj = child;
+        })
+    })
+    Object.keys(entity.actions).forEach(actionName => {
+        const actions = entity.actions[actionName];            
+        switch (actionName) {
+            case "createOne":
+            case "createMany":
+            case "updateOne":
+            case "updateMany":
+            case "updatePartially":
+                actions.forEach(action => action.exclude = action.exclude?.filter(field => allowFields.includes(field)));
+                break;
+        }
+    });
+    removeDisallowedFields(entity.fields, whitelist);
+}
+
+async function writeDocs(filePath, strTemplate, strData) {
+    //const placeholder = "/*INJECT-JAVASCRIPT-HERE*/";
+    /*const idx = strTemplate.indexOf(placeholder);
+    fs.writeFileSync(filePath, strTemplate.substr(0, idx)); 
+    fs.appendFileSync(filePath, "window.docs = ");
+    fs.appendFileSync(filePath, strData);
+    fs.appendFileSync(filePath, ";\n");
+    fs.appendFileSync(filePath, await minify(path.join(__dirname, "../docs/docs.v2.js"), {
+        js: {
+            compress: true
+        }
+    }));
+    fs.appendFileSync(filePath, strTemplate.substr(idx + placeholder.length));*/
+
+    const placeholder = '<script id="INJECT-JAVASCRIPT-HERE"></script>';
+    const idx = strTemplate.indexOf(placeholder);
+    fs.writeFileSync(filePath, strTemplate.substr(0, idx)); 
+    fs.appendFileSync(filePath, "<script>window.docs = ");
+    fs.appendFileSync(filePath, strData);
+    fs.appendFileSync(filePath, ";\n");
+    fs.appendFileSync(filePath, fs.readFileSync(path.join(__dirname, "../docs/docs.v2.js")));
+    fs.appendFileSync(filePath, "</script>");
+    fs.appendFileSync(filePath, strTemplate.substr(idx + placeholder.length));
+
+    fs.writeFileSync(filePath, await minify(filePath, {
+        "html": {
+            "removeComments": true,
+            "removeCommentsFromCDATA": true,
+            "removeCDATASectionsFromCDATA": true,
+            "collapseWhitespace": true,
+            "collapseBooleanAttributes": true,
+            "removeAttributeQuotes": true,
+            "removeRedundantAttributes": true,
+            "useShortDoctype": true,
+            "removeEmptyAttributes": true,
+            "removeEmptyElements": false,
+            "removeOptionalTags": true,
+            "removeScriptTypeAttributes": false,
+            "removeStyleLinkTypeAttributes": true,
+            "minifyJS": true,
+            "minifyCSS": true
+        }
+    }));
 }
 
 async function genDocs(args, projectName, project, alias, source) {
@@ -105,6 +230,8 @@ async function genDocs(args, projectName, project, alias, source) {
         throw new Error(`Not found gen docs configuration. Please run 'npx mushroom-cli config ${projectName} gen docs OUTPUT_FILE.html${alias === "default" ? "" : " alias " + alias}' first`);
     }
 
+    console.log("Use GenDocEngine v1.2");
+
     const entities = common.getEntities(source, aliasProject.allowRoles);
 
     if (Array.isArray(aliasProject.entities)) {
@@ -117,9 +244,55 @@ async function genDocs(args, projectName, project, alias, source) {
         }
     }
 
-    //const html = await fetch('https://api.siten.vn/gen/docs.html').then(res => res.text());
-    const html = fs.readFileSync(__dirname + "/../docs/docs.html").toString();
-    await processGenDocs(aliasProject, entities, source, html, args, projectName, alias);
+    filterEnvironmentVariables(source.environmentVariables);
+    filterEntities(entities);
+
+    const data = JSON.stringify({
+        info: {
+            name: source.name,
+            rootUrl: source.codeHint?.rootUrl ?? source.rootUrl,
+            description: source.description,
+            security: source.security === undefined ? undefined : {
+                crossDomain: source.security.crossDomain,
+                allowOrigins: source.security.allowOrigins
+            }
+        },
+        features: aliasProject.features,
+        roles: source.roles,
+        environmentVariables: source.environmentVariables,
+        entities: entities
+    });
+    // fs.writeFileSync(__dirname + "/../docs/sample.json", data);
+
+    const html = fs.readFileSync(__dirname + "/../docs/docs.v2.html").toString();    
+
+    if (args[3] === "tmp") {
+        const htmlFilePath = aliasProject.output + "_tmp.html";
+        console.log(`Writing to ${htmlFilePath}`);
+        await writeDocs(htmlFilePath, html, data);
+
+        console.log("Opening file " + htmlFilePath);
+        try {
+            await open(htmlFilePath);
+
+            setTimeout(() => {
+                fs.unlink(htmlFilePath, ex => {
+                    if (ex)
+                        console.error("Unable to delete file " + htmlFilePath)
+                });
+            }, 1000);
+        } catch(_) {
+            console.error("Unable to open " + htmlFilePath)
+        }
+        
+        return;
+    }
+
+    common.ensureFolder(aliasProject.output);
+
+    console.log(`Writing to ${aliasProject.output}`);
+    await writeDocs(aliasProject.output, html, data);
+    console.log(`Generated API docs for ${projectName}@${alias} to ${aliasProject.output}`)
 }
 
 module.exports = genDocs;

package/gen.js

@@ -6,6 +6,7 @@ const help = require("./help.js");
 const masterFile = require("./master-file/master-file");
 
 const genApiDocs = require("./gen/gen-api-docs");
+const genApiDocsV1 = require("./gen/gen-api-docs-v1");
 const genDatabaseDocs = require("./gen/gen-db-docs");
 const javascriptDriverGenerator = require("./gen/gen-js-driver");
 const genJavascriptDriverTarball = require("./gen/gen-js-driver-tarball");
@@ -85,7 +86,10 @@ async function gen(args) {
     const type = args[2];
     switch (type) {
         case "docs":
-            await genApiDocs(args, projectName, project, alias, source);
+            if (args.includes("v1"))
+                await genApiDocsV1(args.filter(p => p != "v1"), projectName, project, alias, source);
+            else    
+                await genApiDocs(args, projectName, project, alias, source);
             break;
         case "db-docs":
             genDatabaseDocs(args, projectName, project, alias, source);

package/mr.js

@@ -31,6 +31,7 @@ async function run(args) {
         checkUpdateTask.catch(() => {});
     }
 
+    const startTime = new Date().getTime();
     try {
         switch(args[0]) {
             case "init":
@@ -48,10 +49,6 @@ async function run(args) {
             case "update":
                 await update(args);
                 break;
-            case "":
-            case undefined:
-                console.log(`Mushroom CLI`);
-                break;
             case "help":
             case "man":
                 help(args.slice(1).join());
@@ -62,7 +59,10 @@ async function run(args) {
         }
     }
     catch (e) {
-        console.error(debugMode ? e : e.message);
+        console.error(debugMode ? e : "ERROR: " + e.message);
+    }
+    finally {
+        console.log("Processed in", new Date().getTime() - startTime, "ms.");
     }
     
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mushroom-cli",
-  "version": "1.2.0-alpha.7.1",
+  "version": "1.2.0-alpha.9",
   "description": "Mushroom CLI",
   "main": "mr.js",
   "scripts": {
@@ -16,10 +16,11 @@
   },
   "author": "suco2007",
   "license": "ISC",
-  "dependencies-comments": "node-fetch: 2.x; open: 8.x",
+  "dependencies-comments": "node-fetch: 2.x; open: 8.x; minify: 7.x",
   "dependencies": {
     "jsdom": "^22.1.0",
     "json5": "^2.2.3",
+    "minify": "7.2.2",
     "node-fetch": "^2.6.11",
     "open": "^8.4.2",
     "readline-sync": "^1.4.10",