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

package/dist/common.js

@@ -0,0 +1,260 @@
+import fs from 'fs';
+import path from 'path';
+import readlineSync from 'readline-sync';
+export function ensureFolder(path, isFolder) {
+    const index = path.lastIndexOf('/');
+    if (!isFolder && index <= 0) {
+        return;
+    }
+    if (!isFolder)
+        path = path.substring(0, index);
+    if (path === '.' || path === '..')
+        return;
+    if (!fs.existsSync(path)) {
+        fs.mkdirSync(path, { recursive: true, mode: 0o755 });
+    }
+}
+export function getRootUrl(projectApiConfiguration) {
+    return projectApiConfiguration.codeHint && projectApiConfiguration.codeHint.rootUrl
+        ? projectApiConfiguration.codeHint.rootUrl
+        : projectApiConfiguration.rootUrl;
+}
+export function getEntities(projectApiConfiguration, roles, getAll) {
+    if (!projectApiConfiguration || !projectApiConfiguration.entities || !Array.isArray(projectApiConfiguration.entities))
+        return {};
+    const entities = {};
+    projectApiConfiguration.entities.forEach((entity) => {
+        if (entity.disabled)
+            return;
+        if (getAll) {
+            entities[entity.name] = entity;
+            entity.storageName = entity.storageName ? entity.storageName : entity.name;
+            if (!roles || !roles.length)
+                roles = ['*'];
+            return;
+        }
+        for (const actionName in entity.actions) {
+            entity.actions[actionName].forEach((action) => {
+                var _a;
+                if (!action.grant || !action.enabled || (action.codeHint && action.codeHint.disabled))
+                    return;
+                let allow = roles?.includes('*') || action.grant === '*';
+                if (!allow)
+                    action.grant.split('|').forEach(function (roleGroup) {
+                        if (!roleGroup)
+                            return;
+                        roleGroup.split('+').forEach(function (grantedRole) {
+                            if (roles?.indexOf(grantedRole) !== -1)
+                                allow = true;
+                        });
+                    });
+                if (!allow)
+                    return;
+                if (!(entity.name in entities)) {
+                    entities[entity.name] = {
+                        name: entity.name,
+                        description: entity.description,
+                        storageName: entity.storageName ? entity.storageName : entity.name,
+                        fields: entity.fields,
+                        views: {},
+                    };
+                }
+                const actions = ((_a = entities[entity.name]).actions ?? (_a.actions = {}));
+                actions[actionName] ?? (actions[actionName] = []);
+                actions[actionName].push(action);
+            });
+        }
+        for (const viewName in entity.views) {
+            entity.views[viewName].forEach(function (view) {
+                var _a;
+                if (!view.grant || !view.enabled)
+                    return;
+                let allow = roles?.indexOf('*') !== -1 || view.grant === '*';
+                view.grant.split('|').forEach(function (roleGroup) {
+                    if (!roleGroup)
+                        return;
+                    roleGroup.split('+').forEach(function (grantedRole) {
+                        if (roles?.indexOf(grantedRole) !== -1)
+                            allow = true;
+                    });
+                });
+                if (!allow)
+                    return;
+                if (!(entity.name in entities)) {
+                    entities[entity.name] = {
+                        name: entity.name,
+                        description: entity.description,
+                        storageName: entity.storageName ? entity.storageName : entity.name,
+                        fields: entity.fields,
+                        actions: {},
+                        views: {},
+                    };
+                }
+                const views = ((_a = entities[entity.name]).views ?? (_a.views = {}));
+                views[viewName] ?? (views[viewName] = []);
+                views[viewName].push(view);
+            });
+        }
+        if (entity.name in entities) {
+            entities[entity.name].features = entity.features;
+        }
+    });
+    return entities;
+}
+export function filterRoles(roleList, allowRoleList) {
+    const roles = !allowRoleList || allowRoleList.includes('*')
+        ? [...roleList]
+        : roleList.filter((role) => allowRoleList.includes(role.name));
+    roles.push({
+        name: '[Mọi người dùng]',
+        description: 'Tất cả người dùng (kể cả chưa đăng nhập)',
+    });
+    return roles;
+}
+export function processTemplate(basePath, templatePath) {
+    const templateJsonContent = fs.readFileSync(path.join(basePath, templatePath)).toString();
+    const template = JSON.parse(templateJsonContent);
+    if (template && typeof template !== 'object') {
+        throw new TypeError(`Invalid template file ${templatePath}`);
+    }
+    const commands = template.steps;
+    if (!Array.isArray(commands)) {
+        throw new TypeError(`Invalid template file ${templatePath}`);
+    }
+    const variables = {};
+    commands.forEach((command) => processCommand(command, basePath, variables));
+    return variables;
+}
+function processCommand(command, basePath, variables) {
+    const commandName = command.command;
+    switch (commandName) {
+        case 'input':
+            processInputCommand(command, variables);
+            return;
+        case 'set':
+            processSetCommand(command, variables);
+            return;
+        case 'rename':
+            processRenameCommand(command, basePath, variables);
+            return;
+        case 'delete':
+            processDeleteCommand(command, basePath, variables);
+            return;
+        case 'replace':
+            processReplaceCommand(command, basePath, variables);
+            return;
+        default:
+            throw new Error(`Unknown command: ${commandName}`);
+    }
+}
+function processInputCommand(command, variables) {
+    const value = readlineSync.question(command.message ?? '');
+    if (command.validation) {
+        if (command.validation.required) {
+            if (value === '')
+                throw new TypeError(`${command.variable} is required`);
+        }
+        if (command.validation.pattern) {
+            if (!new RegExp(command.validation.pattern).test(value))
+                throw new Error(`${value} is not valid`);
+        }
+    }
+    variables[command.variable] = value;
+}
+function processSetCommand(command, variables) {
+    switch (command['function']) {
+        case 'New-GUID':
+            processSetNewGuidCommand(command.variable, variables);
+            break;
+        case 'New-RandomNumber':
+            processSetNewRandomNumberCommand(command.variable, variables, command.min, command.max);
+            break;
+        case 'New-RandomString':
+            processSetNewRandomStringCommand(command.variable, variables, command.length, command.characterPool);
+            break;
+        case 'ToLowerCase':
+            toLowerCommand(command.variable, variables, command.input);
+            break;
+        case 'ToUpperCase':
+            toUpperCaseCommand(command.variable, variables, command.input);
+            break;
+        case 'Trim':
+            trimCommand(command.variable, variables, command.input);
+            break;
+        case 'Replace':
+            replaceCommand(command.variable, variables, command.input, command.replacement, command.pattern, command.mode);
+            break;
+        default:
+            throw new Error(`Unknown set-command: ${command['function']}`);
+    }
+}
+function processSetNewGuidCommand(variable, variables) {
+    variables[variable] = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'
+        .replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c == 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    })
+        .toUpperCase();
+}
+function processSetNewRandomNumberCommand(variable, variables, min = 0, max = (1 << 30) * 4) {
+    variables[variable] = Math.floor(min + Math.random() * (max - min)).toString();
+}
+function processSetNewRandomStringCommand(variable, variables, length, characterPool = '1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM') {
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += characterPool.charAt(Math.floor(Math.random() * characterPool.length));
+    }
+    variables[variable] = result;
+}
+function toLowerCommand(variable, variables, input) {
+    variables[variable] = variables[input].toLowerCase();
+}
+function toUpperCaseCommand(variable, variables, input) {
+    variables[variable] = variables[input].toUpperCase();
+}
+function trimCommand(variable, variables, input) {
+    variables[variable] = variables[input].trim();
+}
+function replaceCommand(variable, variables, input, replacement, pattern, mode) {
+    const regex = new RegExp(pattern, mode);
+    variables[variable] = variables[input].replace(regex, replacement);
+}
+function processRenameCommand(command, basePath, variables) {
+    const input = replaceVariables(command.input, variables);
+    const output = replaceVariables(command.output, variables);
+    fs.renameSync(path.join(basePath, input), path.join(basePath, output));
+}
+function processDeleteCommand(command, basePath, variables) {
+    const input = replaceVariables(command.input, variables);
+    const deletedPath = path.join(basePath, input);
+    if (fs.lstatSync(deletedPath).isDirectory()) {
+        fs.rmSync(deletedPath, { recursive: true, force: true });
+    }
+    else {
+        fs.rmSync(deletedPath, { force: true });
+    }
+}
+function processReplaceCommand(command, basePath, variables) {
+    const files = command.input;
+    const pattern = new RegExp(command.pattern ?? '', 'g');
+    const replacement = replaceVariables(command.replacement ?? '', variables);
+    files.forEach((file) => {
+        const filePath = replaceVariables(file, variables);
+        let content = fs.readFileSync(path.join(basePath, filePath)).toString();
+        content = content.replace(pattern, () => replacement);
+        fs.writeFileSync(path.join(basePath, filePath), content);
+    });
+}
+function replaceVariables(str, variables) {
+    return str.replace(/\$\{(\w+)\}/g, (_, varName) => variables[varName] ?? '');
+}
+export function logInfo(message, ...parameters) {
+    console.log(message, ...parameters);
+}
+export function logWarning(message, ...parameters) {
+    console.warn(message, ...parameters);
+}
+export function logError(message, ...parameters) {
+    console.error(message, ...parameters);
+}

package/dist/config.js

@@ -0,0 +1,394 @@
+import fs from 'fs';
+import JSON5 from 'json5';
+import help from './help.js';
+import * as common from './common.js';
+function saveConfig(mushroomConfig, success) {
+    mushroomConfig['$schema'] = 'http://schema.siten.vn/mushroom/mushroom-cli.json';
+    fs.writeFile('./mushroom-config.json', JSON.stringify(mushroomConfig, null, '  '), (err) => {
+        if (err)
+            throw err;
+        if (typeof success === 'function')
+            success();
+    });
+}
+function copyProperties(source, destination) {
+    for (const key in source) {
+        destination[key] = source[key];
+    }
+}
+function configAdd(args) {
+    const filePath = args[2];
+    if (!filePath) {
+        help('config add', true);
+        return;
+    }
+    const fileContent = fs.readFileSync(filePath).toString();
+    const project = JSON5.parse(fileContent);
+    if (!project.name) {
+        throw new TypeError(`Missing name in ${filePath}`);
+    }
+    let mushroomConfigContent;
+    try {
+        mushroomConfigContent = fs.readFileSync('./mushroom-config.json').toString();
+    }
+    catch {
+        mushroomConfigContent = null;
+    }
+    const mushroomConfig = mushroomConfigContent ? JSON.parse(mushroomConfigContent) : {};
+    mushroomConfig.projects = mushroomConfig.projects || {};
+    mushroomConfig.projects[project.name] = mushroomConfig.projects[project.name] || {};
+    mushroomConfig.projects[project.name].src = filePath;
+    saveConfig(mushroomConfig, () => common.logInfo('Added', filePath, 'in project', project.name));
+}
+function configGenDocs(args, mushroomConfig, projectName) {
+    const path = args[4];
+    if (!path) {
+        help(args);
+        return;
+    }
+    let index = 5;
+    const parameters = {
+        output: path,
+        features: [],
+        allowRoles: ['*'],
+        denyRoles: [],
+    };
+    let alias = 'default';
+    while (index < args.length) {
+        switch (args[index]) {
+            case 'features': {
+                index++;
+                const strFeatures = args[index];
+                if (strFeatures)
+                    parameters.features = strFeatures.split(',');
+                break;
+            }
+            case 'roles': {
+                index++;
+                const strRoles = args[index];
+                if (strRoles) {
+                    const minusIndex = strRoles.indexOf('-');
+                    let grantedRoles = minusIndex == -1 ? strRoles : strRoles.substring(0, minusIndex);
+                    const deniedRoles = minusIndex == -1 ? '' : strRoles.substring(minusIndex + 1);
+                    if (!grantedRoles)
+                        grantedRoles = '*';
+                    parameters.allowRoles = grantedRoles.split(',');
+                    if (deniedRoles)
+                        parameters.denyRoles = deniedRoles.split(',');
+                }
+                break;
+            }
+            case 'alias': {
+                index++;
+                const strAlias = args[index];
+                if (strAlias)
+                    alias = strAlias;
+                break;
+            }
+        }
+        index++;
+    }
+    const project = mushroomConfig.projects[projectName];
+    const docs = project.docs || {};
+    docs.alias = docs.alias || {};
+    const projectAlias = (docs.alias[alias] = docs.alias[alias] || {});
+    copyProperties(parameters, projectAlias);
+    saveConfig(mushroomConfig, () => common.logInfo(`Saved configuration of gen docs for ${projectName}@${alias}`));
+}
+function configGenDatabaseDocs(args, mushroomConfig, projectName) {
+    const path = args[4];
+    if (!path) {
+        help(args);
+        return;
+    }
+    let index = 5;
+    const parameters = {
+        output: path,
+        features: [],
+    };
+    let alias = 'default';
+    while (index < args.length) {
+        switch (args[index]) {
+            case 'features': {
+                index++;
+                const strFeatures = args[index];
+                if (strFeatures)
+                    parameters.features = strFeatures.split(',');
+                break;
+            }
+            case 'alias': {
+                index++;
+                const strAlias = args[index];
+                if (strAlias)
+                    alias = strAlias;
+                break;
+            }
+        }
+        index++;
+    }
+    const project = mushroomConfig.projects[projectName];
+    const dbDocs = project.dbDocs || {};
+    dbDocs.alias = dbDocs.alias || {};
+    const projectAlias = (dbDocs.alias[alias] = dbDocs.alias[alias] || {});
+    copyProperties(parameters, projectAlias);
+    saveConfig(mushroomConfig, () => common.logInfo(`Saved configuration of gen db-docs for ${projectName}@${alias}`));
+}
+function configGenJavascriptDriver(args, mushroomConfig, projectName) {
+    const path = args[4];
+    if (!path) {
+        help(args);
+        return;
+    }
+    let index = 5;
+    const parameters = {
+        output: path,
+        allowRoles: ['*'],
+        denyRoles: [],
+    };
+    let alias = 'default';
+    while (index < args.length) {
+        switch (args[index]) {
+            case 'roles': {
+                index++;
+                const strRoles = args[index];
+                if (strRoles) {
+                    const minusIndex = strRoles.indexOf('-');
+                    let grantedRoles = minusIndex == -1 ? strRoles : strRoles.substring(0, minusIndex);
+                    const deniedRoles = minusIndex == -1 ? '' : strRoles.substring(minusIndex + 1);
+                    if (!grantedRoles)
+                        grantedRoles = '*';
+                    parameters.allowRoles = grantedRoles.split(',');
+                    if (deniedRoles)
+                        parameters.denyRoles = deniedRoles.split(',');
+                }
+                break;
+            }
+            case 'alias': {
+                index++;
+                const strAlias = args[index];
+                if (strAlias)
+                    alias = strAlias;
+                break;
+            }
+            case 'tarball': {
+                index++;
+                const strTarball = args[index];
+                if (strTarball)
+                    parameters.tarballName = strTarball;
+                break;
+            }
+        }
+        index++;
+    }
+    const project = mushroomConfig.projects[projectName];
+    const jsDriver = project.jsDriver || {};
+    jsDriver.alias = jsDriver.alias || {};
+    const projectAlias = (jsDriver.alias[alias] = jsDriver.alias[alias] || {});
+    copyProperties(parameters, projectAlias);
+    saveConfig(mushroomConfig, () => common.logInfo(`Saved configuration of gen javascript driver for ${projectName}@${alias}`));
+}
+function configGenTypescriptDriver(args, mushroomConfig, projectName) {
+    const path = args[4];
+    if (!path) {
+        help(args);
+        return;
+    }
+    let index = 5;
+    const parameters = {
+        output: path,
+        allowRoles: ['*'],
+        denyRoles: [],
+    };
+    let alias = 'default';
+    while (index < args.length) {
+        switch (args[index]) {
+            case 'roles': {
+                index++;
+                const strRoles = args[index];
+                if (strRoles) {
+                    const minusIndex = strRoles.indexOf('-');
+                    let grantedRoles = minusIndex == -1 ? strRoles : strRoles.substring(0, minusIndex);
+                    const deniedRoles = minusIndex == -1 ? '' : strRoles.substring(minusIndex + 1);
+                    if (!grantedRoles)
+                        grantedRoles = '*';
+                    parameters.allowRoles = grantedRoles.split(',');
+                    if (deniedRoles)
+                        parameters.denyRoles = deniedRoles.split(',');
+                }
+                break;
+            }
+            case 'alias': {
+                index++;
+                const strAlias = args[index];
+                if (strAlias)
+                    alias = strAlias;
+                break;
+            }
+        }
+        index++;
+    }
+    const project = mushroomConfig.projects[projectName];
+    const tsDriver = project.tsDriver || {};
+    tsDriver.alias = tsDriver.alias || {};
+    const projectAlias = (tsDriver.alias[alias] = tsDriver.alias[alias] || {});
+    copyProperties(parameters, projectAlias);
+    saveConfig(mushroomConfig, () => common.logInfo(`Saved configuration of gen javascript driver for ${projectName}@${alias}`));
+}
+function configGenCSharpMongo(args, mushroomConfig, projectName) {
+    const path = args[4];
+    if (!path) {
+        help(args);
+        return;
+    }
+    let index = 5;
+    const parameters = {
+        output: path,
+    };
+    let alias = 'default';
+    while (index < args.length) {
+        switch (args[index]) {
+            case 'alias': {
+                index++;
+                const strAlias = args[index];
+                if (strAlias)
+                    alias = strAlias;
+                break;
+            }
+        }
+        index++;
+    }
+    const project = mushroomConfig.projects[projectName];
+    const csharpMongo = project.csharpMongo || {};
+    csharpMongo.alias = csharpMongo.alias || {};
+    const projectAlias = (csharpMongo.alias[alias] = csharpMongo.alias[alias] || {});
+    copyProperties(parameters, projectAlias);
+    saveConfig(mushroomConfig, () => common.logInfo(`Saved configuration of gen CSharp/MongoDb classes for ${projectName}@${alias}`));
+}
+function configGenCSharpDriver(args, mushroomConfig, projectName) {
+    const path = args[4];
+    if (!path) {
+        help(args);
+        return;
+    }
+    let index = 5;
+    const parameters = {
+        output: path,
+        allowRoles: ['*'],
+        denyRoles: [],
+        features: ['auth', 'file', 'mail'],
+        accessModifier: 'internal',
+    };
+    let alias = 'default';
+    while (index < args.length) {
+        switch (args[index]) {
+            case 'roles': {
+                index++;
+                const strRoles = args[index];
+                if (strRoles) {
+                    const minusIndex = strRoles.indexOf('-');
+                    let grantedRoles = minusIndex == -1 ? strRoles : strRoles.substring(0, minusIndex);
+                    const deniedRoles = minusIndex == -1 ? '' : strRoles.substring(minusIndex + 1);
+                    if (!grantedRoles)
+                        grantedRoles = '*';
+                    parameters.allowRoles = grantedRoles.split(',');
+                    if (deniedRoles)
+                        parameters.denyRoles = deniedRoles.split(',');
+                }
+                break;
+            }
+            case 'alias': {
+                index++;
+                const strAlias = args[index];
+                if (strAlias)
+                    alias = strAlias;
+                break;
+            }
+            case 'access-modifier': {
+                index++;
+                const strAccessModifier = args[index];
+                if (strAccessModifier)
+                    parameters.accessModifier = strAccessModifier;
+                break;
+            }
+            case 'features': {
+                index++;
+                const strFeatures = args[index];
+                if (strFeatures) {
+                    parameters.features = strFeatures.split(',');
+                }
+                break;
+            }
+        }
+        index++;
+    }
+    const project = mushroomConfig.projects[projectName];
+    const csharpDriver = project.csharpDriver || {};
+    csharpDriver.alias = csharpDriver.alias || {};
+    const projectAlias = (csharpDriver.alias[alias] = csharpDriver.alias[alias] || {});
+    copyProperties(parameters, projectAlias);
+    saveConfig(mushroomConfig, () => common.logInfo(`Saved configuration of gen CSharp driver for ${projectName}@${alias}`));
+}
+function configGen(args) {
+    const projectName = args[2];
+    let mushroomConfig;
+    try {
+        const mushroomConfigContent = fs.readFileSync('./mushroom-config.json').toString();
+        mushroomConfig = JSON.parse(mushroomConfigContent);
+    }
+    catch (e) {
+        common.logError('mushroom-config.json not found or unable to parse');
+        throw e;
+    }
+    if (!mushroomConfig || !mushroomConfig.projects || !mushroomConfig.projects[projectName])
+        throw new Error(`Project not found (${projectName})`);
+    const type = args[3];
+    switch (type) {
+        case 'docs':
+            configGenDocs(args, mushroomConfig, projectName);
+            break;
+        case 'db-docs':
+            configGenDatabaseDocs(args, mushroomConfig, projectName);
+            break;
+        case 'js-driver':
+            configGenJavascriptDriver(args, mushroomConfig, projectName);
+            break;
+        case 'ts-driver':
+            configGenTypescriptDriver(args, mushroomConfig, projectName);
+            break;
+        case 'c#-mongo':
+            configGenCSharpMongo(args, mushroomConfig, projectName);
+            break;
+        case 'c#-driver':
+            configGenCSharpDriver(args, mushroomConfig, projectName);
+            break;
+        case '':
+        case undefined:
+        case 'help':
+        case 'man':
+            help(args);
+            break;
+        default:
+            help(args, true);
+            break;
+    }
+}
+export default function config(args) {
+    const configCommand = args[1];
+    switch (configCommand) {
+        case 'add':
+            configAdd(args);
+            break;
+        case 'gen':
+            configGen(args);
+            break;
+        case '':
+        case undefined:
+        case 'help':
+        case 'man':
+            help('config');
+            break;
+        default:
+            help(args, true);
+            break;
+    }
+}