mushroom-cli 1.2.0-alpha.1 → 1.2.0-alpha.11

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: common.filterRoles(source.roles ?? [], aliasProject.allowRoles),
+        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/gen-csharp.js

@@ -134,7 +134,7 @@ function generateEnumClass(source, out, field, defaultClassName) {
                 strEnumClasses += `    /// <summary>
     /// ${singleLine(validation.codeHint.validValues.description || field.description)}
     /// </summary>
-    public class ${enumClassName}
+    public partial class ${enumClassName}
     {
         private ${enumClassName}() { }
 
@@ -179,7 +179,7 @@ function generateCSharpClassMongoDb(source, className, fields, isRoot, descripti
 
         supperClass = " : Mushroom.Models.IResource<" + getCSharpTypeFromMushroomType(source, fields.id.type, true) + ">";
     }
-    content += `    public class ${className}${supperClass}
+    content += `    public partial class ${className}${supperClass}
     {
 `;
     for (var fieldName in fields) {
@@ -488,21 +488,6 @@ namespace ${namespace}
     {
 ${collectionNames}
         public static IMongoDatabase GetDatabase() => Mushroom.MushroomDaoFactory.GetDbAdapter() as IMongoDatabase;
-        
-        public static async System.Threading.Tasks.Task<T> FindByIdAsync<T, TId>(this IMongoCollection<T> collection, TId id) where T : Mushroom.Models.IResource<TId>
-        {
-            return await (await collection.FindAsync(Builders<T>.Filter.Eq(doc => doc.Id, id))).FirstOrDefaultAsync();
-        }
-        
-        public static async System.Threading.Tasks.Task<T> FindByIdAsync<T, TId>(this IMongoCollection<T> collection, TId id, FindOptions<T> findOptions) where T : Mushroom.Models.IResource<TId>
-        {
-            return await (await collection.FindAsync(Builders<T>.Filter.Eq(doc => doc.Id, id), findOptions)).FirstOrDefaultAsync();
-        }
-        
-        public static async System.Threading.Tasks.Task<T> FindByIdAsync<T, TId>(this IMongoCollection<T> collection, TId id, ProjectionDefinition<T> projection) where T : Mushroom.Models.IResource<TId>
-        {
-            return await (await collection.FindAsync(Builders<T>.Filter.Eq(doc => doc.Id, id), new FindOptions<T> { Projection = projection })).FirstOrDefaultAsync();
-        }
     }
 
     public class ResourceNames
@@ -587,7 +572,7 @@ function generateCSharpClassMongoDbToFolder(source, className, fields, isRoot, d
 
         supperClass = " : Mushroom.Models.IResource<" + getCSharpTypeFromMushroomType(source, fields.id.type, true) + ">";
     }
-    content += `    public class ${className}${supperClass}
+    content += `    public partial class ${className}${supperClass}
     {
 `;
     for (var fieldName in fields) {
@@ -653,7 +638,7 @@ function generateCSharpClassMongoDbToFolder(source, className, fields, isRoot, d
 
         let strEnumClasses = generateEnumClass(source, {}, field, `${className.toUpperCase()}_${propertyName.toUpperCase()}_ENUM`);
 
-        const match = strEnumClasses.match(/public class\s+(\w+)/);
+        const match = strEnumClasses.match(/public partial class\s+(\w+)/);
         if (!match) continue;
         common.ensureFolder(aliasProject.output + "/Enums", true);
         strEnumClasses = `${header}