mushroom-cli 1.2.0-alpha.2 → 1.2.0-alpha.20

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

@@ -0,0 +1,306 @@
+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) {
+    if (!environmentVariables)
+        return;
+    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'];
+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))
+            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) => allowFields.includes(field))));
+                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 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];
+                }
+            }
+        }
+    }
+    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,
+    });
+    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}`);
+}