mushroom-cli 1.2.7 → 1.2.9

package/README.md

@@ -132,6 +132,13 @@ npx mushroom-cli parameters --no-check-update
 
 ## Version
 
+### 1.2.8
+
+Improvement
+
+- gen docs: fix bug: gen docs fail when entity action has codehint.delegator.params
+- gen docs: fix bug: gen wrong docs for entity view params
+
 ### 1.2.6, 1.2.7
 
 Hot fixed

package/dist/docs/docs.v2.js

@@ -1025,7 +1025,7 @@ function renderGeneralAction(args) {
         type: (field.type === 'array' ? 'array of ' : '') + (field.items?.type ?? 'string'),
         description: field.description ?? '',
         required: field.required ? 'required' : 'optional',
-        validation: getValidationStringDocs(p, true),
+        validation: getValidationStringDocs(field, true),
       })
     }).join('');
   } else {
@@ -1150,7 +1150,7 @@ function renderEntityViewRolePage(entityName, viewName, grant) {
           type: (p.isArray ? 'array of ' : '') + (p.type ?? 'string'),
           description: p.description ?? '',
           defaultValue: p.defaultValue ? `, default (${p.defaultValue})` : '',
-          required: p.required ? 'required' : 'optional',
+          required: p.validation?.required ? 'required' : 'optional',
           validation: getValidationStringDocs(p.validation, true),
         }),
       )

package/dist/gen/csharp/extEvents.js

@@ -0,0 +1,195 @@
+const extEvents = {
+    auth: {
+        'Events.Login.Before': {
+            type: 'Before',
+        },
+        'Events.Login.Validate.Before': {
+            type: 'Before',
+        },
+        'Events.Login.Validate.After': {
+            type: 'After',
+        },
+        'Events.Login.CheckLocking.Before': {
+            type: 'Before',
+        },
+        'Events.Login.CheckLocking.After': {
+            type: 'After',
+            data: 'Mushroom.Extensions.DefaultAuth.UserLock',
+        },
+        CustomLoginAsyncFunc: {
+            type: 'Func',
+            registerFunc: 'RegisterCustomLoginAsyncHandler',
+        },
+        'Events.Login.LogAuth.Before': {
+            type: 'Before',
+        },
+        GetAuthLogInfoAsyncFunc: {
+            type: 'Func',
+            registerFunc: 'RegisterGetAuthLogInfoAsyncHandler',
+        },
+        'Events.Login.LogAuth.After': {
+            type: 'After',
+            data: 'Mushroom.Extensions.DefaultAuth.UserAuthLogResult',
+        },
+        'Events.Login.LoginFail': {
+            type: 'After',
+        },
+        'Events.Login.LoginSuccess': {
+            type: 'Event',
+            registerFunc: 'RegisterLoginSuccessHandler',
+        },
+        'Events.Login.After': {
+            type: 'After',
+            data: 'string',
+        },
+        'Events.Logout.Before': {
+            type: 'Before',
+        },
+        'Events.Logout.After': {
+            type: 'After',
+            data: 'bool',
+        },
+        'Events.Status.Before': {
+            type: 'Before',
+        },
+        'Events.Status.After': {
+            type: 'After',
+            data: 'bool',
+        },
+        'Events.Me.Before': {
+            type: 'Before',
+        },
+        'Events.Me.After': {
+            type: 'After',
+            data: 'Mushroom.Extensions.DefaultAuth.User',
+        },
+        'Events.Register.Before': {
+            type: 'Before',
+        },
+        SendCodeItemFunc: {
+            type: 'Func',
+            registerFunc: 'RegisterSendCodeItemHandler',
+        },
+        'Events.Register.After': {
+            type: 'After',
+            data: 'Mushroom.Extensions.DefaultAuth.User',
+        },
+        'Events.Activate.Before': {
+            type: 'Before',
+        },
+        'Events.Activate.After': {
+            type: 'After',
+            data: 'Mushroom.Extensions.DefaultAuth.User',
+        },
+        'Events.RecoverPassword.Before': {
+            type: 'Before',
+        },
+        'Events.RecoverPassword.After': {
+            type: 'After',
+            data: 'Mushroom.Extensions.DefaultAuth.User',
+        },
+        'Events.ResetPassword.Before': {
+            type: 'Before',
+        },
+        'Events.ResetPassword.After': {
+            type: 'After',
+            data: 'Mushroom.Extensions.DefaultAuth.User',
+        },
+    },
+    file: {
+        'Events.Upload.Before': {
+            type: 'Before',
+        },
+        'Events.Upload.After': {
+            type: 'After',
+        },
+        'Events.Thumb.Before': {
+            type: 'Before',
+        },
+        'Events.Thumb.After': {
+            type: 'After',
+        },
+        'Events.Download.Before': {
+            type: 'Before',
+        },
+        'Events.Download.After': {
+            type: 'After',
+        },
+        'Events.Zip.Before': {
+            type: 'Before',
+        },
+        'Events.Zip.After': {
+            type: 'After',
+        },
+        LimitFileUploadSizeFunc: {
+            type: 'Func',
+            data: 'System.Threading.Tasks.Task<long?>',
+        },
+    },
+    mail: {
+        AuthorizationFunc: {
+            type: 'Func',
+            data: 'System.Threading.Tasks.Task<bool>, Mushroom.Extensions.Mailing.MailingAuthorizationArgument',
+        },
+    },
+};
+export const getExtensionEventsCode = (source, newLine) => {
+    const eventCodes = [];
+    const addEventCodes = (key, code, source) => {
+        const eventCode = eventCodes.find((ec) => ec.key === key);
+        if (eventCode) {
+            eventCode.source.push(source);
+            return;
+        }
+        eventCodes.push({
+            key,
+            code,
+            source: [source],
+        });
+    };
+    Object.keys(extEvents).forEach((ext) => {
+        const extension = source.extensions?.[ext];
+        if (!extension?.config)
+            return;
+        const config = extension.config;
+        Object.keys(extEvents[ext]).forEach((configName) => {
+            const def = extEvents[ext][configName];
+            const configValue = config[configName];
+            if (!configValue || typeof configValue !== 'string' || !configValue.startsWith('lib:'))
+                return;
+            if (def.type == 'Func') {
+                const defaultFunc = `RegisterCustomMethod<${def.data || 'System.Threading.Tasks.Task'}>`;
+                addEventCodes(ext + '.' + configName, `${def.registerFunc || defaultFunc}(${configValue.substring(4)});`, `extension: ${ext} - config: ${configName}`);
+                return;
+            }
+            if (def.type == 'Event') {
+                configValue.split(',').forEach((lib) => {
+                    if (!lib || !lib.startsWith('lib:'))
+                        return;
+                    addEventCodes(ext + '.' + configName, `${def.registerFunc || 'RegisterEvent'}(${lib.substring(4)});`, `extension: ${ext} - config: ${configName}`);
+                });
+                return;
+            }
+            if (def.type == 'Before') {
+                configValue.split(',').forEach((lib) => {
+                    if (!lib || !lib.startsWith('lib:'))
+                        return;
+                    addEventCodes(ext + '.' + configName, `${def.registerFunc || 'RegisterBeforeEvent'}(${lib.substring(4)});`, `extension: ${ext} - config: ${configName}`);
+                });
+                return;
+            }
+            if (def.type == 'After') {
+                configValue.split(',').forEach((lib) => {
+                    if (!lib || !lib.startsWith('lib:'))
+                        return;
+                    addEventCodes(ext + '.' + configName, `${def.registerFunc || (def.data ? `RegisterAfterEvent<${def.data}>` : 'RegisterAfterEvent')}(${lib.substring(4)});`, `extension: ${ext} - config: ${configName}`);
+                });
+                return;
+            }
+            return '';
+        });
+    });
+    return eventCodes
+        .map((ec) => `${ec.source.map((s) => '            // ' + s).join(newLine)}${newLine}            ${ec.code}`)
+        .join(newLine);
+};

package/dist/gen/gen-csharp.js

@@ -435,7 +435,21 @@ namespace ${namespace}
     public static class DbConnector
     {
 ${collectionNames}
-        public static IMongoDatabase GetDatabase() => Mushroom.MushroomDaoFactory.GetDbAdapter() as IMongoDatabase;
+        public static IMongoDatabase GetDatabase()
+        {
+            try
+            {
+                if (Mushroom.MushroomDaoFactory.GetDbAdapter() is IMongoDatabase db) return db;
+            }
+            catch
+            {
+                // Not in mushrom context
+            }
+
+            // Use DbAdapter of the first project in MushroomServer for default
+            var project = Mushroom.MushroomServer.GetAllApis().First();
+            return Mushroom.MushroomDaoFactory.GetDbAdapter(project.IdType, project.ConnectionString) as IMongoDatabase;
+        }
     }
 
     public class ResourceNames
@@ -790,7 +804,21 @@ namespace ${namespace}
     public static class DbConnector
     {
 ${collectionNames}
-        public static IMongoDatabase GetDatabase() => Mushroom.MushroomDaoFactory.GetDbAdapter() as IMongoDatabase;
+        public static IMongoDatabase GetDatabase()
+        {
+            try
+            {
+                if (Mushroom.MushroomDaoFactory.GetDbAdapter() is IMongoDatabase db) return db;
+            }
+            catch
+            {
+                // Not in mushrom context
+            }
+
+            // Use DbAdapter of the first project in MushroomServer for default
+            var project = Mushroom.MushroomServer.GetAllApis().First();
+            return Mushroom.MushroomDaoFactory.GetDbAdapter(project.IdType, project.ConnectionString) as IMongoDatabase;
+        }
     }
 }
 `;

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

@@ -0,0 +1,52 @@
+import * as common from '../common.js';
+export function listApi(source) {
+    const entities = common.getEntities(source, ['*'], true);
+    const endpoints = new Set();
+    for (const entityName in entities) {
+        const actions = entities[entityName].actions || {};
+        for (const actionName in actions) {
+            const action = actions[actionName];
+            if (!Array.isArray(action) || !action.length || action.every((a) => !a.enabled))
+                continue;
+            let method;
+            let id = '';
+            if (actionName == 'findById') {
+                method = 'GET';
+                id = '/{{id}}';
+            }
+            if (actionName == 'findMany')
+                method = 'GET';
+            else if (actionName == 'createOne' || actionName == 'createMany')
+                method = 'POST';
+            else if (actionName?.startsWith('_raw_http_method_')) {
+                method = 'POST';
+                id = '/' + actionName.substring('_raw_http_method_'.length);
+            }
+            else if (actionName == 'updateOne') {
+                method = 'PUT';
+                id = '/{{id}}';
+            }
+            else if (actionName == 'updateMany')
+                method = 'PUT';
+            else if (actionName == 'updatePartially') {
+                method = 'PATCH';
+                id = '/{{id}}';
+            }
+            else if (actionName == 'deleteOne') {
+                method = 'DELETE';
+                id = '/{{id}}';
+            }
+            else if (actionName == 'deleteMany')
+                method = 'DELETE';
+            endpoints.add(`${method} ${source.rootUrl}${entityName}s${id}`);
+        }
+        const views = entities[entityName].views || {};
+        for (const viewName in views) {
+            const view = views[viewName];
+            if (!Array.isArray(view) || !view.length || view.every((v) => !v.enabled))
+                continue;
+            endpoints.add(`GET ${source.rootUrl}${entityName}s/views/${viewName}`);
+        }
+    }
+    endpoints.forEach((e) => console.log(e));
+}

package/dist/gen.js

@@ -10,6 +10,7 @@ import genDatabaseDocs from './gen/gen-db-docs.js';
 import * as javascriptDriverGenerator from './gen/gen-js-driver.js';
 import genJavascriptDriverTarball from './gen/gen-js-driver-tarball.js';
 import * as typescriptDriverGenerator from './gen/gen-ts-driver.js';
+import * as listApi from './gen/gen-list-api.js';
 import * as csharp from './gen/gen-csharp.js';
 export default async function gen(args) {
     let projectName = args[1];
@@ -96,7 +97,9 @@ export default async function gen(args) {
         case 'c#-driver':
             csharp.genCSharpDriver(args, projectName, project, alias, source);
             break;
-        case '':
+        case 'list-api':
+            listApi.listApi(source);
+            break;
         case undefined:
         case 'help':
         case 'man':

package/dist/init/netcore/templateProcessor.js

@@ -0,0 +1,182 @@
+import fs from 'fs';
+import path from 'path';
+import readlineSync from 'readline-sync';
+import * as common from '../../common.js';
+export function process(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 resolvedInput = replaceVariables(file, variables);
+        const filePaths = resolveInputPaths(basePath, resolvedInput);
+        if (filePaths.length === 0) {
+            common.logWarning(`File ${file} does not exist, skipping...`);
+            return;
+        }
+        filePaths.forEach((filePath) => {
+            let content = fs.readFileSync(filePath).toString();
+            content = content.replace(pattern, () => replacement);
+            fs.writeFileSync(filePath, content);
+        });
+    });
+}
+function resolveInputPaths(basePath, input) {
+    const fileName = path.basename(input);
+    if (/[*?]/.test(fileName)) {
+        const dir = path.join(basePath, path.dirname(input));
+        if (!fs.existsSync(dir)) {
+            return [];
+        }
+        return findFilesByGlob(dir, globToRegExp(fileName));
+    }
+    const filePath = path.join(basePath, input);
+    return fs.existsSync(filePath) ? [filePath] : [];
+}
+function globToRegExp(glob) {
+    const pattern = glob
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+    return new RegExp(`^${pattern}$`, 'i');
+}
+function findFilesByGlob(dir, fileNamePattern) {
+    const results = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    entries.forEach((entry) => {
+        const entryPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...findFilesByGlob(entryPath, fileNamePattern));
+        }
+        else if (fileNamePattern.test(entry.name)) {
+            results.push(entryPath);
+        }
+    });
+    return results;
+}
+function replaceVariables(str, variables) {
+    return str.replace(/\$\{(\w+)\}/g, (_, varName) => variables[varName] ?? '');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mushroom-cli",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "description": "Mushroom CLI",
   "main": "dist/mr.js",
   "type": "module",