mushroom-cli 1.2.0-alpha.9 → 1.2.1

package/dist/docs/mt.extension.js

@@ -0,0 +1,199 @@
+(function () {
+  var urls = {};
+  function loadFile(url, successCallback, errorCallback) {
+    if (url in urls) {
+      var args = urls[url];
+      args.cached = true;
+      setTimeout(successCallback, 1, args);
+      return;
+    }
+    var xhr = new XMLHttpRequest();
+    xhr.onreadystatechange = function () {
+      if (this.readyState !== 4) return;
+      if (this.status < 200 || this.status >= 300) {
+        if (typeof this.debugMode === "function" && this.debugMode())
+          console.error("Unable to load: " + url);
+        return;
+      }
+      var args = { content: this.responseText };
+      urls[url] = args;
+      if (typeof successCallback === "function") successCallback(args);
+    };
+    xhr.onerror = function () {
+      if (typeof this.debugMode === "function" && this.debugMode())
+        console.error("Error occurred when loading: " + url);
+      if (typeof errorCallback === "function") errorCallback();
+    };
+    xhr.onabort = function () {
+      if (typeof this.debugMode === "function" && this.debugMode())
+        console.error("Connection aborted: " + url);
+      if (typeof errorCallback === "function") errorCallback();
+    };
+    xhr.ontimeout = function () {
+      if (typeof this.debugMode === "function" && this.debugMode())
+        console.error("Connection timeout: " + url);
+      if (typeof errorCallback === "function") errorCallback();
+    };
+    xhr.open("GET", url, true);
+    xhr.send(null);
+  }
+
+  mt.modules = {};
+  mt.bindModule = function (module, dom, data, session) {
+    if (!module || !dom) return;
+
+    loadFile(
+      "/modules/" + module + "/" + module + "-view.html",
+      function (response) {
+        dom.innerHTML =
+          "<link rel='stylesheet' href='/modules/" +
+          module +
+          "/" +
+          module +
+          "-style.min.css' />" +
+          response.content;
+        loadFile(
+          "/modules/" + module + "/" + module + "-script.js",
+          function (resp) {
+            if (!resp.content) return;
+
+            if (!resp.cached) {
+              try {
+                eval(resp.content);
+              } catch (e) {
+                throw "Invalid module script";
+              }
+              if (!mt.modules[module]) throw "Invalid module script";
+              if (typeof mt.modules[module].init === "function")
+                mt.modules[module].init();
+            }
+
+            var config = mt.modules[module];
+
+            var args = {
+              dom: dom,
+              data: data,
+              fnPool: config.fn,
+              session: session,
+            };
+            if (typeof config.prebinding === "function") {
+              config.prebinding(args);
+            }
+
+            mt.bindDom(dom, args.data, args.fnPool, session);
+
+            if (typeof config.load === "function") {
+              args.dom = dom;
+              args.session = session;
+              config.load(args);
+            }
+          },
+          function () {
+            mt.bindDom(dom, data, null, session);
+          },
+        );
+      },
+    );
+  };
+
+  //#region mt-link
+  if (mt["default"] === undefined) mt["default"] = {};
+  if (mt["default"].mtLink === undefined) mt["default"].mtLink = {};
+  // cho phép mở rộng được về sau: ví dụ thay thế bằng custom dialog
+  mt["default"].mtLink.itemClickHandler = function (dom, message, callback) {
+    if (confirm(message)) callback(dom);
+  };
+
+  function mtLinkHandler(dom) {
+    mt.bindModule(
+      dom.__mtLinkConfig.module,
+      document.getElementById("page-wrapper"),
+      dom.__mtLinkConfig.params,
+    );
+  }
+
+  function mtLinkClicked(e) {
+    if (this.__mtLinkConfig.confirm)
+      mt["default"].mtLink.itemClickHandler(
+        this,
+        this.__mtLinkConfig.confirm,
+        mtLinkHandler,
+      );
+    else mtLinkHandler(this);
+
+    e = e || window.event;
+    e.stopPropagation();
+    e.preventDefault();
+    e.cancelBubble = true;
+    return false;
+  }
+
+  mt.registerDomFeature("mtLink", function (arg) {
+    if (arg.dom.nodeName !== "A") {
+      arg.dom.dataset.mtLinkError = "mtLink feature only affects <a> tag";
+      return;
+    }
+
+    if (!arg.config.module) {
+      arg.dom.dataset.mtLinkError = "mtLink feature: missing module";
+      return;
+    }
+
+    arg.dom.__mtLinkConfig = mt.fnUtils.mergeData({
+      mask: arg.config,
+      data: arg.data,
+      session: arg.session,
+    });
+
+    if (!arg.dom.href) arg.dom.href = "javascript:void(0)";
+
+    mt.fnUtils.addEventListener(arg.dom, "click", mtLinkClicked, false);
+
+    delete arg.dom.dataset.mtLink;
+  });
+  //#endregion
+
+  //#region mt-module
+  mt.registerDomFeature("mtModule", function (arg) {
+    if (!arg.config.module) {
+      arg.dom.dataset.mtModuleError = "mtModule feature: missing module";
+      return;
+    }
+
+    var params = mt.fnUtils.mergeData({
+      mask: arg.config.params,
+      data: arg.data,
+      session: arg.session,
+    });
+    mt.bindModule(arg.config.module, arg.dom, params, arg.session);
+    arg.mediator.skipInner = true;
+
+    delete arg.dom.dataset.mtModule;
+  });
+  //#endregion
+
+  //#region mt-inline-module
+  mt.inlineModuleTemplates = {};
+  mt.registerDomFeature("mtInlineModule", function (arg) {
+    var config = mt.fnUtils.mergeData({
+      mask: arg.config,
+      data: arg.data,
+      session: arg.session,
+    });
+
+    if (!config.module) {
+      arg.dom.dataset.mtInlineModuleError =
+        "mtInlineModule feature: missing module";
+      return;
+    }
+
+    arg.dom.innerHTML = mt.inlineModuleTemplates[config.module] || "";
+
+    delete arg.dom.dataset.mtInlineModule;
+
+    mt.bindDom(arg.dom, config.params);
+
+    arg.mediator.skipInner = true;
+  });
+  //#endregion
+})();

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

@@ -0,0 +1,110 @@
+import fs from 'fs';
+import open from 'open';
+import jsdom, { JSDOM } from 'jsdom';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import * as common from '../common.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function processGenDocs(aliasProject, entities, source, html, args, projectName, alias) {
+    common.logInfo('Received html');
+    common.logInfo('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) {
+                common.logInfo('GenDocEngine:', msg.substring('MUSHROOM-CLI:'.length));
+            }
+            if (msg === 'MUSHROOM-CLI: FAIL') {
+                reject(err);
+                return;
+            }
+            if (msg !== 'MUSHROOM-CLI: FINISH')
+                return;
+            const code = '<!DOCTYPE html>' + dom.window.document.documentElement.outerHTML;
+            if (args[3] === 'tmp') {
+                const htmlFilePath = aliasProject.output + '_tmp.html';
+                common.logInfo('Writing to', htmlFilePath);
+                fs.writeFile(htmlFilePath, code, (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    common.logInfo('Opening file', htmlFilePath);
+                    open(htmlFilePath)
+                        .then(() => {
+                        setTimeout(() => {
+                            fs.unlink(htmlFilePath, (ex) => {
+                                if (ex)
+                                    common.logError('Unable to delete file', htmlFilePath);
+                            });
+                        }, 1000);
+                    })
+                        .catch(() => common.logError('Unable to open', htmlFilePath));
+                    resolve();
+                });
+                return;
+            }
+            common.ensureFolder(aliasProject.output);
+            common.logInfo('Writing to', aliasProject.output);
+            fs.writeFile(aliasProject.output, code, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                common.logInfo(`Generated API docs for ${projectName}@${alias} to ${aliasProject.output}`);
+                resolve();
+            });
+        });
+        const dom = new JSDOM(html, {
+            runScripts: 'dangerously',
+            resources: 'usable',
+            virtualConsole: virtualConsole,
+        });
+        common.logInfo('Rendering API document');
+    });
+}
+export default 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`);
+    }
+    common.logWarning('[DEPRECATED] 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);
+}

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

@@ -0,0 +1,327 @@
+import fs from 'fs';
+import open from 'open';
+import { minify } from 'minify';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import * as common from '../common.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function reserveWhitelist(obj, whitelist) {
+    if (!obj && typeof obj !== 'object')
+        return null;
+    for (const m in obj) {
+        if (!whitelist.includes(m))
+            delete obj[m];
+    }
+    return obj;
+}
+const environmentVariableWhitelist = ['type', 'description'];
+function filterEnvironmentVariables(environmentVariables, allowRoles) {
+    if (!environmentVariables)
+        return;
+    if (!allowRoles.includes('*')) {
+        Object.keys(environmentVariables).forEach((envName) => {
+            if (environmentVariables[envName].codeHint?.roles?.every((role) => !allowRoles.includes(role))) {
+                delete environmentVariables[envName];
+            }
+        });
+    }
+    Object.values(environmentVariables).forEach((env) => reserveWhitelist(env, environmentVariableWhitelist));
+}
+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', 'result'];
+const fieldsOnlyWhitelist = ['fields'];
+const viewWhitelist = ['grant', 'deny', 'description', 'parameters', 'emptyResult', 'codeHint'];
+const viewCodeHintWhitelist = ['output'];
+function filterEntities(entities) {
+    Object.values(entities).forEach((entity) => {
+        filterEntityFields(entity);
+        if (!reserveWhitelist(entity, entityWhitelist))
+            return;
+        const entityActions = entity.actions ?? {};
+        Object.keys(entityActions).forEach((actionName) => {
+            const actions = entityActions[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 (!action.codeHint)
+                            return;
+                        if (!reserveWhitelist(action.codeHint, actionCodeHintWhitelist))
+                            return;
+                        if (!action.codeHint.delegator)
+                            return;
+                        if (!reserveWhitelist(action.codeHint.delegator, actionCodeHintDelegatorWhitelist))
+                            return;
+                        reserveWhitelist(action.codeHint.delegator.param, fieldsOnlyWhitelist);
+                        reserveWhitelist(action.codeHint.delegator.requestBody, fieldsOnlyWhitelist);
+                    });
+                    break;
+            }
+        });
+        const entityViews = entity.views ?? {};
+        Object.keys(entityViews).forEach((viewName) => {
+            const views = entityViews[viewName];
+            views.forEach((view) => {
+                reserveWhitelist(view, viewWhitelist);
+                if (!view.codeHint)
+                    return;
+                if (!reserveWhitelist(view.codeHint, viewCodeHintWhitelist))
+                    return;
+                reserveWhitelist(view.codeHint.output, fieldsOnlyWhitelist);
+            });
+        });
+        if (entity.features) {
+            reserveWhitelist(entity.features, entityFeatureWhitelist);
+            reserveWhitelist(entity.features.vn_text, vnTextWhitelist);
+            entity.features.vn_text?.channels?.forEach((channel) => reserveWhitelist(channel, vnTextChannelWhitelist));
+        }
+    });
+}
+function flattenFields(fields, dict, prefix) {
+    dict ?? (dict = {});
+    prefix ?? (prefix = '');
+    for (const 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 (const 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 (const m in dict) {
+        if (!dict[m] &&
+            !excludedFields.includes(m) &&
+            excludedFields.every((excludedField) => !m.startsWith(excludedField + '.')))
+            dict[m] = true;
+    }
+}
+function filterEntityFields(entity) {
+    const dict = flattenFields(entity.fields);
+    const entityActions = entity.actions ?? {};
+    Object.keys(entityActions).forEach((actionName) => {
+        const actions = entityActions[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(entityActions).forEach((actionName) => {
+        const actions = entityActions[actionName];
+        switch (actionName) {
+            case 'createOne':
+            case 'createMany':
+            case 'updateOne':
+            case 'updateMany':
+            case 'updatePartially':
+                actions.forEach((action) => {
+                    action.exclude = action.exclude?.filter((field) => {
+                        let idx = 0;
+                        do {
+                            idx = field.indexOf('.', idx + 1);
+                            const prefix = idx === -1 ? field : field.substring(0, idx);
+                            if (allowFields.includes(prefix))
+                                return true;
+                        } while (idx !== -1);
+                        return false;
+                    });
+                });
+                break;
+        }
+    });
+    removeDisallowedFields(entity.fields, whitelist);
+}
+async function writeDocs(filePath, strTemplate, strData) {
+    const placeholder = '<script id="INJECT-JAVASCRIPT-HERE"></script>';
+    const idx = strTemplate.indexOf(placeholder);
+    fs.writeFileSync(filePath, strTemplate.substring(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.substring(idx + placeholder.length));
+    fs.writeFileSync(filePath, await minify(filePath, {
+        html: {
+            removeComments: 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,
+            html5: true,
+        },
+    }));
+    copyStaticFiles(path.dirname(filePath), [
+        'bootstrap-theme.min.css',
+        'bootstrap.min.css',
+        'bootstrap.min.js',
+        'jquery.min.js',
+    ]);
+}
+const copyStaticFiles = (folderPath, files) => {
+    files.forEach((file) => {
+        fs.copyFileSync(path.join(__dirname, '../docs/', file), path.join(folderPath, file));
+    });
+};
+export default 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`);
+    }
+    common.logInfo('Use GenDocEngine v1.2');
+    const allowRoles = aliasProject.allowRoles ?? ['*'];
+    const entities = common.getEntities(source, 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];
+                }
+            }
+        }
+    }
+    filterEnvironmentVariables(source.environmentVariables, allowRoles);
+    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 ?? [], allowRoles),
+        environmentVariables: source.environmentVariables,
+        entities: entities,
+    });
+    const html = fs.readFileSync(__dirname + '/../docs/docs.v2.html').toString();
+    if (args[3] === 'tmp') {
+        const htmlFilePath = aliasProject.output + '_tmp.html';
+        common.logInfo('Writing to', htmlFilePath);
+        await writeDocs(htmlFilePath, html, data);
+        common.logInfo('Opening file ', htmlFilePath);
+        try {
+            await open(htmlFilePath);
+            setTimeout(() => {
+                fs.unlink(htmlFilePath, (ex) => {
+                    if (ex)
+                        common.logError('Unable to delete file', htmlFilePath);
+                });
+            }, 1000);
+        }
+        catch {
+            common.logError('Unable to open', htmlFilePath);
+        }
+        return;
+    }
+    common.ensureFolder(aliasProject.output);
+    common.logInfo('Writing to', aliasProject.output);
+    await writeDocs(aliasProject.output, html, data);
+    common.logInfo(`Generated API docs for ${projectName}@${alias} to ${aliasProject.output}`);
+}