mushroom-cli 1.2.8 → 2.0.0-alpha.1

package/dist/gen/gen-csharp.js

@@ -1,16 +1,19 @@
 import fs from 'fs';
 import * as common from '../common.js';
+import { getExtensionEventsCode } from './csharp/extEvents.js';
 const packageVersion = common.getPackageVersion();
 const newLine = '\n';
 const header = `// NOTE: Please do not modify this file
 // NOTE: Version and compatibility information: please see in Info.cs file
 
 // ReSharper disable CheckNamespace
+// ReSharper disable ClassCannotBeInstantiated
 // ReSharper disable CommentTypo
 // ReSharper disable EmptyNamespace
 // ReSharper disable IdentifierTypo
 // ReSharper disable InconsistentNaming
 // ReSharper disable PartialTypeWithSinglePart
+// ReSharper disable RedundantTypeArgumentsOfMethod
 // ReSharper disable RedundantUsingDirective
 // ReSharper disable StringLiteralTypo
 // ReSharper disable UnusedMember.Global
@@ -18,10 +21,33 @@ const header = `// NOTE: Please do not modify this file
 // ReSharper disable UnusedParameter.Local
 // ReSharper disable UnusedTypeParameter
 `;
-function singleLine(str) {
-    if (!str)
-        return '';
-    return str.replace(/\r/g, '').replace(/\n/g, '<br/>');
+const infoContent = `// Mushroom CLI version: ${packageVersion} (https://www.npmjs.com/package/mushroomjs)${newLine}// Compatible with Mushroom Server version: 0.3 or higher (https://www.nuget.org/packages/Mushroom/)`;
+const helperMethods = `
+        public delegate T GetT<out T>(Mushroom.ActionArguments arg);
+        private void RegisterCustomMethod<T>(GetT<T> handler) { }
+        public delegate TResult GetT<out TResult, in TArguments>(TArguments arg);
+        private void RegisterCustomMethod<TResult, TArguments>(GetT<TResult, TArguments> handler) { }
+        private void RegisterCustomViewMethod(Mushroom.MushroomViewHandler handler) { }
+        private void RegisterCustomVnTextBuilderMethod(Mushroom.Features.VnText.TextProcess handler) { }
+        private void RegisterEvent(Mushroom.BeforeInvokeCommandAsyncHandler handler) { }
+        private void RegisterEvent(Mushroom.BeforeInvokeCommandHandler handler) { }
+        private void RegisterBeforeEvent(Mushroom.Events.BeforeRequestEvent handler) { }
+        private void RegisterAfterEvent(Mushroom.Events.AfterRequestEvent handler) { }
+        private void RegisterAfterEvent<T>(Mushroom.Events.AfterRequestEvent<T> handler) { }
+        private void RegisterCustomLoginAsyncHandler(Mushroom.Extensions.DefaultAuth.LoginAsyncHandler handler) { }
+        private void RegisterGetAuthLogInfoAsyncHandler(Mushroom.Extensions.DefaultAuth.LoginAsyncHandler handler) { }
+        private void RegisterLoginSuccessHandler(Mushroom.Extensions.DefaultAuth.LoginEvents.LoginSuccessHandler handler) { }
+        private void RegisterSendCodeItemHandler(Mushroom.Extensions.DefaultAuth.SendCodeItemHandler handler) { }
+        private void RegisterJob<T>() where T : Mushroom.Job.JobBase { }
+`;
+const xmlEntities = {
+    '<': '&lt;',
+    '>': '&gt;',
+    '&': '&amp;',
+    '\n': '<br/>',
+};
+function escapseForXmlDocs(str) {
+    return str?.replace(/[<>&\n\r]/g, (c) => xmlEntities[c] ?? c) ?? '';
 }
 function toCSharpName(str) {
     if (!str)
@@ -101,31 +127,29 @@ function generateEnumClass(source, out, field, defaultClassName) {
     }
     const type = getCSharpTypeFromMushroomType(source, mrType, true);
     validation.codeHint = validation.codeHint || {};
-    if (validation.validValues) {
-        validation.codeHint.validValues = validation.codeHint.validValues || {};
-        if (!validation.codeHint.validValues.disabled) {
-            const enumClassName = validation.codeHint.validValues.className || defaultClassName;
-            out.arrEnumClassNames ?? (out.arrEnumClassNames = []);
-            if (!out.arrEnumClassNames.includes(enumClassName)) {
-                out.arrEnumClassNames.push(enumClassName);
-                strEnumClasses += `    /// <summary>
-    /// ${singleLine(validation.codeHint.validValues.description || field.description)}
+    validation.codeHint.validValues = validation.codeHint.validValues || {};
+    if (validation.codeHint.validValues.disabled)
+        return '';
+    const enumClassName = validation.codeHint.validValues.className || defaultClassName;
+    out.arrEnumClassNames ?? (out.arrEnumClassNames = []);
+    if (!out.arrEnumClassNames.includes(enumClassName)) {
+        out.arrEnumClassNames.push(enumClassName);
+        strEnumClasses += `    /// <summary>
+    /// ${escapseForXmlDocs(validation.codeHint.validValues.description || field.description)}
     /// </summary>
     public partial class ${enumClassName}
     {
         private ${enumClassName}() { }
 
 `;
-                const enumProperties = validation.codeHint.validValues.nameMap || validation.validValues;
-                for (let i = 0; i < enumProperties.length && i < validation.validValues.length; i++) {
-                    strEnumClasses += `        public const ${type} ${toCSharpName(enumProperties[i])} = ${getCSharpInitValue(type, validation.validValues[i])};
+        const enumProperties = validation.codeHint.validValues.nameMap || validation.validValues;
+        for (let i = 0; i < enumProperties.length && i < validation.validValues.length; i++) {
+            strEnumClasses += `        public const ${type} ${toCSharpName(enumProperties[i])} = ${getCSharpInitValue(type, validation.validValues[i])};
 `;
-                }
-                strEnumClasses += `    }
+        }
+        strEnumClasses += `    }
 
 `;
-            }
-        }
     }
     return strEnumClasses;
 }
@@ -144,13 +168,13 @@ function groupCSharpMethodHandlerByMethod(handlers) {
         return prev;
     }, {});
 }
-function generateCSharpClassMongoDb(source, className, fields, isRoot, description, out) {
+function generateCSharpClassMongoDb(source, className, fields, isRoot, description, out, aliasProject) {
     let strClasses = '';
     let strEnumClasses = '';
     let content = '';
     if (description) {
         content += `    /// <summary>
-    /// ${singleLine(description)}
+    /// ${escapseForXmlDocs(description)}
     /// </summary>
 `;
     }
@@ -177,14 +201,13 @@ function generateCSharpClassMongoDb(source, className, fields, isRoot, descripti
         }
         else if (field.type === 'object') {
             strClasses +=
-                generateCSharpClassMongoDb(source, className + '_' + propertyName, field.fields ?? {}, false, null, out) +
-                    newLine;
+                generateCSharpClassMongoDb(source, className + '_' + propertyName, field.fields ?? {}, false, null, out, aliasProject) + newLine;
             type = className + '_' + propertyName;
         }
         else if (field.type === 'array') {
             if (field.items?.type === 'object') {
                 strClasses +=
-                    generateCSharpClassMongoDb(source, className + '_' + propertyName, field.items.fields ?? {}, false, null, out) + newLine;
+                    generateCSharpClassMongoDb(source, className + '_' + propertyName, field.items.fields ?? {}, false, null, out, aliasProject) + newLine;
                 type = `System.Collections.Generic.List<${className}_${propertyName}>`;
             }
             else if (field.items) {
@@ -194,7 +217,7 @@ function generateCSharpClassMongoDb(source, className, fields, isRoot, descripti
         else
             type = getCSharpTypeFromMushroomType(source, field.type, field.validation && field.validation.required);
         content += `        /// <summary>
-        /// ${singleLine(field.description)}
+        /// ${escapseForXmlDocs(field.description)}
         /// </summary>
 `;
         if (isRoot && fieldName === 'id') {
@@ -216,30 +239,76 @@ function generateCSharpClassMongoDb(source, className, fields, isRoot, descripti
             content +=
                 '        [MongoDB.Bson.Serialization.Attributes.BsonDateTimeOptions(Kind = System.DateTimeKind.Local)]\n';
         }
-        if (field.type === 'array' && field.items) {
-            if ((field.items.type === 'AutoId' || field.items.type === 'IdRef') && source.idType === 'ObjectId') {
+        if (field.type === 'array') {
+            if ((field.items?.type === 'AutoId' || field.items?.type === 'IdRef') && source.idType === 'ObjectId') {
                 content +=
                     '        [MongoDB.Bson.Serialization.Attributes.BsonRepresentation(MongoDB.Bson.BsonType.ObjectId)]\n';
             }
-            if (field.items.type === 'AutoId' && source.idType === 'GUID') {
+            if (field.items?.type === 'AutoId' && source.idType === 'GUID') {
                 content += '        [MongoDB.Bson.Serialization.Attributes.BsonRepresentation(MongoDB.Bson.BsonType.String)]\n';
             }
-            if (field.items.type === 'datetime') {
+            if (field.items?.type === 'datetime') {
                 content +=
                     '        [MongoDB.Bson.Serialization.Attributes.BsonDateTimeOptions(Kind = System.DateTimeKind.Local)]\n';
             }
         }
-        content += `        public ${type} ${propertyName} { get; set; }\n\n`;
-        strEnumClasses += generateEnumClass(source, out, field, `${className.toUpperCase()}_${propertyName.toUpperCase()}_ENUM`);
+        content += `        public ${type} ${propertyName} { get; set; }${newLine}${newLine}`;
+        const strEnumClass = generateEnumClass(source, out, field, `${className.toUpperCase()}_${propertyName.toUpperCase()}_ENUM`);
+        if (!strEnumClass)
+            continue;
+        strEnumClasses += strEnumClass;
+        if (aliasProject.outputToFolder) {
+            const match = strEnumClass.match(/public partial class\s+(\w+)/);
+            if (!match)
+                continue;
+            common.ensureFolder(aliasProject.output + '/Enums', true);
+            const namespace = toCSharpName(source.name);
+            const fileContent = `${header}
+
+namespace ${namespace}.Enums
+{
+${strEnumClass}
+}
+`;
+            fs.writeFileSync(aliasProject.output + '/Enums/' + match[1] + '.cs', fileContent);
+        }
     }
     content += `        [MongoDB.Bson.Serialization.Attributes.BsonExtraElements]
+        [Newtonsoft.Json.JsonIgnore]
+        [System.Text.Json.Serialization.JsonIgnore]
         public System.Collections.Generic.Dictionary<string, object> Mushroom_ExtraProperties { get; set; }
 
     }
 `;
-    if (strEnumClasses) {
-        out.strEnumClasses ?? (out.strEnumClasses = '');
-        out.strEnumClasses += strEnumClasses;
+    if (aliasProject.outputToFolder) {
+        common.ensureFolder(aliasProject.output + '/Resources', true);
+        const namespace = toCSharpName(source.name);
+        content = `${header}
+
+namespace ${namespace}.Resources
+{
+${content}
+}
+`;
+        const normalizedName = className.toLowerCase();
+        out.allClasses ?? (out.allClasses = []);
+        const duplicate = out.allClasses.find((c) => c.normalizedName == normalizedName);
+        if (duplicate) {
+            fs.appendFileSync(aliasProject.output + '/Resources/' + duplicate.className + '.cs', content);
+        }
+        else {
+            out.allClasses.push({
+                className,
+                normalizedName,
+            });
+            fs.writeFileSync(aliasProject.output + '/Resources/' + className + '.cs', content);
+        }
+    }
+    else {
+        if (strEnumClasses) {
+            out.strEnumClasses ?? (out.strEnumClasses = '');
+            out.strEnumClasses += strEnumClasses;
+        }
     }
     return strClasses + newLine + content;
 }
@@ -254,39 +323,44 @@ function getCSharpFunc(methodName, methodType) {
 export function genCSharpMongoDbClasses(args, projectName, project, alias, source) {
     const aliasProject = ((project.csharpMongo || {}).alias || {})[alias];
     if (!aliasProject) {
-        throw new Error(`Not found gen c#-mongo configuration. Please run 'npx mushroom-cli config ${projectName} gen c#-mongo OUTPUT_FILE.cs${alias === 'default' ? '' : ' alias ' + alias}' first`);
+        throw new Error('Not found gen c#-mongo configuration.');
+    }
+    if (fs.existsSync(aliasProject.output)) {
+        try {
+            fs.unlinkSync(aliasProject.output);
+        }
+        catch { }
     }
     if (aliasProject.outputToFolder) {
-        genCSharpMongoDbClassesToFolder(projectName, alias, source, aliasProject);
-        return;
+        if (fs.existsSync(aliasProject.output)) {
+            try {
+                fs.rmSync(aliasProject.output, { recursive: true, force: true });
+            }
+            catch { }
+        }
+        fs.mkdirSync(aliasProject.output, { recursive: true, mode: 0o755 });
     }
     const entities = common.getEntities(source, aliasProject.allowRoles, true);
     const namespace = toCSharpName(source.name);
     let strClasses = '';
-    let strEnumClasses = '';
     let collectionNames = '';
     let resourceNames = '';
-    let roleNames = '';
-    source.roles?.forEach((role) => {
-        if (!role.name)
-            return;
-        roleNames += `
+    const roleNames = source.roles
+        ?.filter((r) => r.name)
+        .map((role) => `
         /// <summary>
         /// ${role.description ?? ''}
         /// </summary>
-        public static string ${toCSharpName(role.name)} => "${role.name}";
-`;
-    });
-    const out = {
-        strEnumClasses: '',
-    };
+        public static string ${toCSharpName(role.name)} => "${role.name}";`)
+        .join(newLine) ?? '';
+    const out = {};
     for (const entityName in entities) {
         const className = toCSharpName(entityName);
         collectionNames += `        public static string ${className}CollectionName => "${entities[entityName].storageName}";
         public static IMongoCollection<Resources.${className}> ${className}Collection => GetDatabase().GetCollection<Resources.${className}>(${className}CollectionName);
 `;
-        resourceNames += `        public static string ${className} => "${entityName}";\n`;
-        strClasses += generateCSharpClassMongoDb(source, className, entities[entityName].fields, true, entities[entityName].description, out);
+        resourceNames += `        public static string ${className} => "${entityName}";${newLine}`;
+        strClasses += generateCSharpClassMongoDb(source, className, entities[entityName].fields, true, entities[entityName].description, out, aliasProject);
         const actions = entities[entityName].actions || {};
         for (const actionName in actions) {
             const action = actions[actionName];
@@ -381,12 +455,10 @@ export function genCSharpMongoDbClasses(args, projectName, project, alias, sourc
             });
         }
     }
-    if (out.strEnumClasses)
-        strEnumClasses += out.strEnumClasses;
     const delegators = groupCSharpMethodHandlerByMethod(out.delegators);
     const strDelegatorReferences = Object.keys(delegators)
         .map((method) => delegators[method].map((ev) => `            // ${ev.source}`).join(newLine) +
-        `\n            RegisterCustomMethod(${getCSharpFunc(method, delegators[method][0].type)});`)
+        `\n            RegisterCustomMethod<System.Threading.Tasks.Task>(${getCSharpFunc(method, delegators[method][0].type)});`)
         .join(newLine);
     const viewHandlers = groupCSharpMethodHandlerByMethod(out.viewHandlers);
     const strViewHandlerReferences = Object.keys(viewHandlers)
@@ -413,69 +485,57 @@ export function genCSharpMongoDbClasses(args, projectName, project, alias, sourc
             .map((job) => `            RegisterJob<${job.action.substring(4).split(',')[0]}>();`)
             .join(newLine)
         : '';
-    const code = `// This file was generated by Mushroom CLI ${packageVersion} (https://www.npmjs.com/package/mushroom-cli), please do not modify
-
-// NOTE: Compatible with Mushroom Server version 0.2.18 or higher (https://www.nuget.org/packages/Mushroom/)
-
-// ReSharper disable RedundantUsingDirective
-// ReSharper disable InconsistentNaming
-// ReSharper disable PartialTypeWithSinglePart
-// ReSharper disable UnusedMember.Global
-// ReSharper disable UnusedMember.Local
-// ReSharper disable UnusedParameter.Local
-// ReSharper disable IdentifierTypo
-// ReSharper disable StringLiteralTypo
-// ReSharper disable CommentTypo
-// ReSharper disable EmptyNamespace
+    const strRouteHandlers = source.routes
+        ?.filter((route) => route.delegator.startsWith('lib:'))
+        .map((route) => `            // route: ${route.path} - grant: ${route.grant}${newLine}            RegisterCustomMethod<System.Threading.Tasks.Task>(${getCSharpFunc(route.delegator.substring(4), route.codeHint?.delegator?.csharp?.methodType ?? 'static')});`)
+        .join(newLine) ?? '';
+    const strExtensionEventHandlers = getExtensionEventsCode(source, newLine);
+    if (aliasProject.outputToFolder) {
+        const dbConnectorFileContent = `${header}
+using MongoDB.Driver;
 
 namespace ${namespace}
 {
-    using MongoDB.Driver;
-    
     public static class DbConnector
     {
 ${collectionNames}
         public static IMongoDatabase GetDatabase() => Mushroom.MushroomDaoFactory.GetDbAdapter() as IMongoDatabase;
     }
+}
+`;
+        const resourceNamesFileContent = `${header}
 
+namespace ${namespace}
+{
     public class ResourceNames
     {
         private ResourceNames() { }
 
 ${resourceNames}
     }
+}
+`;
+        const roleNamesFileContent = `${header}
 
-    public class RoleNames {
+namespace ${namespace}
+{
+    public class RoleNames
+    {
         private RoleNames() { }
 
 ${roleNames}
     }
 }
-
-namespace ${namespace}.Resources
-{
-${strClasses}
-}
-
-namespace ${namespace}.Enums
-{
-${strEnumClasses}
-}
+`;
+        const refactorHelperFileContent = `${header}
 
 #if DEBUG
-namespace ${namespace}.CodeHelper
+namespace ${namespace}
 {
     class RefactorHelper
     {
         private RefactorHelper() { }
-        private void RegisterCustomMethod(System.Func<Mushroom.ActionArguments, System.Threading.Tasks.Task> fn) { }
-        private void RegisterCustomMethod(System.Action<Mushroom.ActionArguments> fn) { }
-        private void RegisterCustomViewMethod(System.Func<Mushroom.ViewArguments, System.Threading.Tasks.Task<System.Collections.Generic.IEnumerable<object>>> fn) { }
-        private void RegisterCustomViewMethod(System.Func<Mushroom.ViewArguments, System.Collections.Generic.IEnumerable<object>> fn) { }
-        private void RegisterCustomVnTextBuilderMethod(System.Func<System.Collections.Generic.IEnumerable<string>, System.Collections.Generic.IEnumerable<string>> fn) { }
-        private void RegisterEvent(System.Func<object, Mushroom.ActionArguments, System.Threading.Tasks.Task> fn) { }
-        private void RegisterEvent(System.Action<object, Mushroom.ActionArguments> fn) { }
-        private void RegisterJob<T>() where T : Mushroom.Job.JobBase { }
+${helperMethods}
         private void Help()
         {
 ${strDelegatorReferences}
@@ -483,359 +543,66 @@ ${strViewHandlerReferences}
 ${strVnTextChannels}
 ${strEventHandlerReferences}
 ${strJobReferences}
+${strRouteHandlers}
+${strExtensionEventHandlers}
         }
     }
 }
 #endif
 `;
-    common.ensureFolder(aliasProject.output);
-    fs.writeFile(aliasProject.output, code, (err) => {
-        if (err)
-            throw err;
-        common.logInfo(`Generated CSharp MongoDb Classes for ${projectName}@${alias} to ${aliasProject.output}`);
-    });
-}
-function generateCSharpClassMongoDbToFolder(source, className, fields, isRoot, description, out, aliasProject) {
-    let content = '';
-    const namespace = toCSharpName(source.name);
-    if (description) {
-        content += `    /// <summary>
-    /// ${singleLine(description)}
-    /// </summary>
-`;
-    }
-    let supperClass = '';
-    if (isRoot) {
-        if (!fields.id) {
-            fields.id = {
-                type: 'AutoId',
-            };
-        }
-        if (!fields.id.type)
-            fields.id.type = 'AutoId';
-        supperClass = ' : Mushroom.Models.IResource<' + getCSharpTypeFromMushroomType(source, fields.id.type, true) + '>';
-    }
-    content += `    public partial class ${className}${supperClass}
-    {
-`;
-    for (const fieldName in fields) {
-        const field = fields[fieldName];
-        let type;
-        const propertyName = toCSharpName(fieldName);
-        if (field.codeHint && field.codeHint.type && field.codeHint.type.csharp) {
-            type = field.codeHint.type.csharp;
-        }
-        else if (field.type === 'object') {
-            generateCSharpClassMongoDbToFolder(source, className + '_' + propertyName, field.fields ?? {}, false, null, out, aliasProject);
-            type = className + '_' + propertyName;
-        }
-        else if (field.type === 'array') {
-            if (field.items?.type === 'object') {
-                generateCSharpClassMongoDbToFolder(source, className + '_' + propertyName, field.items.fields ?? {}, false, null, out, aliasProject);
-                type = `System.Collections.Generic.List<${className}_${propertyName}>`;
-            }
-            else if (field.items) {
-                type = `System.Collections.Generic.List<${getCSharpTypeFromMushroomType(source, field.items.type, field.items.validation && field.items.validation.required)}>`;
-            }
-        }
-        else
-            type = getCSharpTypeFromMushroomType(source, field.type, field.validation && field.validation.required);
-        content += `        /// <summary>
-        /// ${singleLine(field.description)}
-        /// </summary>
-`;
-        if (isRoot && fieldName === 'id') {
-            content += `        [MongoDB.Bson.Serialization.Attributes.BsonId${field.type === 'AutoId' && source.idType === 'GUID' ? '(IdGenerator = typeof(MongoDB.Bson.Serialization.IdGenerators.GuidGenerator))' : ''}]\n`;
-        }
-        content += `        [MongoDB.Bson.Serialization.Attributes.BsonElement("${isRoot && fieldName === 'id' ? '_id' : fieldName}")]
-        [MongoDB.Bson.Serialization.Attributes.BsonIgnoreIfNull]
-        [Newtonsoft.Json.JsonProperty(PropertyName = "${fieldName}", NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore${type === 'System.DateTime' ? ', DefaultValueHandling = Newtonsoft.Json.DefaultValueHandling.Ignore' : ''})]
-        [System.Text.Json.Serialization.JsonPropertyName("${fieldName}")]
-        [System.Text.Json.Serialization.JsonIgnore(Condition = ${type === 'System.DateTime' ? 'System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingDefault' : 'System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull'})]
-`;
-        if ((field.type === 'AutoId' || field.type === 'IdRef') && source.idType === 'ObjectId') {
-            content += '        [MongoDB.Bson.Serialization.Attributes.BsonRepresentation(MongoDB.Bson.BsonType.ObjectId)]\n';
-        }
-        if (field.type === 'AutoId' && source.idType === 'GUID') {
-            content += '        [MongoDB.Bson.Serialization.Attributes.BsonRepresentation(MongoDB.Bson.BsonType.String)]\n';
-        }
-        if (field.type === 'datetime') {
-            content +=
-                '        [MongoDB.Bson.Serialization.Attributes.BsonDateTimeOptions(Kind = System.DateTimeKind.Local)]\n';
-        }
-        if (field.type === 'array') {
-            if ((field.items?.type === 'AutoId' || field.items?.type === 'IdRef') && source.idType === 'ObjectId') {
-                content +=
-                    '        [MongoDB.Bson.Serialization.Attributes.BsonRepresentation(MongoDB.Bson.BsonType.ObjectId)]\n';
-            }
-            if (field.items?.type === 'AutoId' && source.idType === 'GUID') {
-                content += '        [MongoDB.Bson.Serialization.Attributes.BsonRepresentation(MongoDB.Bson.BsonType.String)]\n';
-            }
-            if (field.items?.type === 'datetime') {
-                content +=
-                    '        [MongoDB.Bson.Serialization.Attributes.BsonDateTimeOptions(Kind = System.DateTimeKind.Local)]\n';
-            }
-        }
-        content += `        public ${type} ${propertyName} { get; set; }
-
-`;
-        let strEnumClasses = generateEnumClass(source, {}, field, `${className.toUpperCase()}_${propertyName.toUpperCase()}_ENUM`);
-        const match = strEnumClasses.match(/public partial class\s+(\w+)/);
-        if (!match)
-            continue;
-        common.ensureFolder(aliasProject.output + '/Enums', true);
-        strEnumClasses = `${header}
-
-namespace ${namespace}.Enums
-{
-${strEnumClasses}
-}
-`;
-        fs.writeFileSync(aliasProject.output + '/Enums/' + match[1] + '.cs', strEnumClasses);
-    }
-    content += `        [MongoDB.Bson.Serialization.Attributes.BsonExtraElements]
-        [Newtonsoft.Json.JsonIgnore]
-        [System.Text.Json.Serialization.JsonIgnore]
-        public System.Collections.Generic.Dictionary<string, object> Mushroom_ExtraProperties { get; set; }
-
-    }
-`;
-    common.ensureFolder(aliasProject.output + '/Resources', true);
-    content = `${header}
-
-namespace ${namespace}.Resources
-{
-${content}
-}
-`;
-    const normalizedName = className.toLowerCase();
-    out.allClasses ?? (out.allClasses = []);
-    const duplicate = out.allClasses.find((c) => c.normalizedName == normalizedName);
-    if (duplicate) {
-        fs.appendFileSync(aliasProject.output + '/Resources/' + duplicate.className + '.cs', content);
+        fs.writeFileSync(aliasProject.output + '/DbConnector.cs', dbConnectorFileContent);
+        fs.writeFileSync(aliasProject.output + '/ResourceNames.cs', resourceNamesFileContent);
+        fs.writeFileSync(aliasProject.output + '/RoleNames.cs', roleNamesFileContent);
+        fs.writeFileSync(aliasProject.output + '/RefactorHelper.cs', refactorHelperFileContent);
+        fs.writeFileSync(aliasProject.output + '/Info.cs', infoContent);
+        common.logInfo(`Generated CSharp MongoDb Classes for ${projectName}@${alias} to folder ${aliasProject.output}`);
     }
     else {
-        out.allClasses.push({
-            className,
-            normalizedName,
-        });
-        fs.writeFileSync(aliasProject.output + '/Resources/' + className + '.cs', content);
-    }
-}
-function genCSharpMongoDbClassesToFolder(projectName, alias, source, aliasProject) {
-    if (fs.existsSync(aliasProject.output)) {
-        try {
-            fs.unlinkSync(aliasProject.output);
-        }
-        catch { }
-        try {
-            fs.rmSync(aliasProject.output, { recursive: true, force: true });
-        }
-        catch { }
-    }
-    fs.mkdirSync(aliasProject.output, { recursive: true, mode: 0o755 });
-    const entities = common.getEntities(source, aliasProject.allowRoles, true);
-    const namespace = toCSharpName(source.name);
-    let collectionNames = '';
-    let resourceNames = '';
-    let roleNames = '';
-    source.roles?.forEach((role) => {
-        if (!role.name)
-            return;
-        roleNames += `
-        /// <summary>
-        /// ${role.description ?? ''}
-        /// </summary>
-        public static string ${toCSharpName(role.name)} => "${role.name}";
-`;
-    });
-    const out = {};
-    for (const entityName in entities) {
-        const className = toCSharpName(entityName);
-        collectionNames += `        public static string ${className}CollectionName => "${entities[entityName].storageName}";
-        public static IMongoCollection<Resources.${className}> ${className}Collection => GetDatabase().GetCollection<Resources.${className}>(${className}CollectionName);
-`;
-        resourceNames += `        public static string ${className} => "${entityName}";
-`;
-        generateCSharpClassMongoDbToFolder(source, className, entities[entityName].fields, true, entities[entityName].description, out, aliasProject);
-        const actions = entities[entityName].actions || {};
-        for (const actionName in actions) {
-            const action = actions[actionName];
-            if (!Array.isArray(action))
-                continue;
-            action.forEach((a) => {
-                if (!a)
-                    return;
-                if (typeof a.delegator === 'string' && a.delegator.indexOf('lib:') === 0) {
-                    const method = a.delegator.substring(4);
-                    let type = a.codeHint && a.codeHint.delegator && a.codeHint.delegator.csharp
-                        ? a.codeHint.delegator.csharp.methodType
-                        : null;
-                    if (type !== 'non-static')
-                        type = 'static';
-                    out.delegators ?? (out.delegators = []);
-                    out.delegators.push({
-                        method: method,
-                        source: `entity: ${entityName}, action: ${actionName}, grant: ${a.grant}`,
-                        type: type,
-                    });
-                }
-                if (!a.events && !(typeof a.events === 'object'))
-                    return;
-                for (const eventName in a.events) {
-                    if (!Array.isArray(a.events[eventName]))
-                        return;
-                    a.events[eventName].forEach((ev, i) => {
-                        if (typeof ev !== 'string' || ev.indexOf('lib:') !== 0)
-                            return;
-                        const method = ev.substring(4);
-                        let type = a.codeHint &&
-                            a.codeHint.events &&
-                            Array.isArray(a.codeHint.events[eventName]) &&
-                            a.codeHint.events[eventName][i] &&
-                            a.codeHint.events[eventName][i].csharp
-                            ? a.codeHint.events[eventName][i].csharp.methodType
-                            : null;
-                        if (type !== 'non-static')
-                            type = 'static';
-                        out.eventHandlers ?? (out.eventHandlers = []);
-                        out.eventHandlers.push({
-                            method: method,
-                            source: `entity: ${entityName}, action: ${actionName}, grant: ${a.grant}, event: ${eventName}`,
-                            type: type,
-                        });
-                    });
-                }
-            });
-        }
-        const views = entities[entityName].views || {};
-        for (const viewName in views) {
-            const view = views[viewName];
-            if (!Array.isArray(view))
-                continue;
-            view.forEach((v) => {
-                if (!v)
-                    return;
-                if (typeof v.query === 'string' && v.query.indexOf('lib:') === 0) {
-                    const method = v.query.substring(4);
-                    let type = v.codeHint && v.codeHint.query && v.codeHint.query.csharp ? v.codeHint.query.csharp.methodType : null;
-                    if (type !== 'non-static')
-                        type = 'static';
-                    out.viewHandlers ?? (out.viewHandlers = []);
-                    out.viewHandlers.push({
-                        method: method,
-                        source: `entity: ${entityName}, view: ${viewName}, grant: ${v.grant}`,
-                        type: type,
-                    });
-                }
-            });
-        }
-        const channels = entities[entityName].features?.vn_text?.channels;
-        if (channels != null) {
-            channels.forEach((channel) => {
-                if (!channel.nativeBuilder ||
-                    typeof channel.nativeBuilder !== 'string' ||
-                    channel.nativeBuilder.indexOf('lib:') !== 0)
-                    return;
-                const method = channel.nativeBuilder.substring(4);
-                let type = channel.codeHint && channel.codeHint.nativeBuilder && channel.codeHint.nativeBuilder.csharp
-                    ? channel.codeHint.nativeBuilder.csharp.methodType
-                    : null;
-                if (type !== 'non-static')
-                    type = 'static';
-                out.vnTextChannels ?? (out.vnTextChannels = []);
-                out.vnTextChannels.push({
-                    method: method,
-                    source: `entity: ${entityName}, feature: vn_text, channel: ${channel.name}`,
-                    type: type,
-                });
-            });
-        }
-    }
-    const delegators = groupCSharpMethodHandlerByMethod(out.delegators);
-    const strDelegatorReferences = Object.keys(delegators)
-        .map((method) => delegators[method].map((ev) => `            // ${ev.source}`).join(newLine) +
-        `\n            RegisterCustomMethod(${getCSharpFunc(method, delegators[method][0].type)});`)
-        .join(newLine);
-    const viewHandlers = groupCSharpMethodHandlerByMethod(out.viewHandlers);
-    const strViewHandlerReferences = Object.keys(viewHandlers)
-        .map((method) => viewHandlers[method].map((ev) => `            // ${ev.source}`).join(newLine) +
-        `\n            RegisterCustomViewMethod(${getCSharpFunc(method, viewHandlers[method][0].type)});`)
-        .join(newLine);
-    const vnTextChannels = groupCSharpMethodHandlerByMethod(out.vnTextChannels);
-    const strVnTextChannels = Object.keys(vnTextChannels)
-        .map((method) => vnTextChannels[method].map((channel) => `            // ${channel.source}`).join(newLine) +
-        `\n            RegisterCustomVnTextBuilderMethod(${getCSharpFunc(method, vnTextChannels[method][0].type)});`)
-        .join(newLine);
-    const eventHandlers = groupCSharpMethodHandlerByMethod(out.eventHandlers);
-    const strEventHandlerReferences = Object.keys(eventHandlers)
-        .map((method) => eventHandlers[method].map((ev) => `            // ${ev.source}`).join(newLine) +
-        `\n            RegisterEvent(${getCSharpFunc(method, eventHandlers[method][0].type)});`)
-        .join(newLine);
-    const strJobReferences = Array.isArray(source.jobs)
-        ? source.jobs
-            .filter((job) => job !== null &&
-            typeof job === 'object' &&
-            job.action &&
-            typeof job.action === 'string' &&
-            job.action.indexOf('lib:') === 0)
-            .map((job) => `            RegisterJob<${job.action.substring(4).split(',')[0]}>();`)
-            .join(newLine)
-        : '';
-    const dbConnectorFileContent = `${header}
-using MongoDB.Driver;
+        const fullCode = `${infoContent}
+
+${header}
 
 namespace ${namespace}
 {
+    using MongoDB.Driver;
+    
     public static class DbConnector
     {
 ${collectionNames}
         public static IMongoDatabase GetDatabase() => Mushroom.MushroomDaoFactory.GetDbAdapter() as IMongoDatabase;
     }
-}
-`;
-    const resourceNamesFileContent = `${header}
 
-namespace ${namespace}
-{
     public class ResourceNames
     {
         private ResourceNames() { }
 
 ${resourceNames}
     }
-}
-`;
-    const roleNamesFileContent = `${header}
 
-namespace ${namespace}
-{
-    public class RoleNames
-    {
+    public class RoleNames {
         private RoleNames() { }
 
 ${roleNames}
     }
 }
-`;
-    const refactorHelperFileContent = `${header}
+
+namespace ${namespace}.Resources
+{
+${strClasses}
+}
+
+namespace ${namespace}.Enums
+{
+${out.strEnumClasses ?? ''}
+}
 
 #if DEBUG
-namespace ${namespace}
+namespace ${namespace}.CodeHelper
 {
     class RefactorHelper
     {
         private RefactorHelper() { }
-        private void RegisterCustomMethod(System.Func<Mushroom.ActionArguments, System.Threading.Tasks.Task> fn) { }
-        private void RegisterCustomMethod(System.Action<Mushroom.ActionArguments> fn) { }
-        private void RegisterCustomViewMethod(System.Func<Mushroom.ViewArguments, System.Threading.Tasks.Task<System.Collections.Generic.IEnumerable<object>>> fn) { }
-        private void RegisterCustomViewMethod(System.Func<Mushroom.ViewArguments, System.Collections.Generic.IEnumerable<object>> fn) { }
-        private void RegisterCustomVnTextBuilderMethod(System.Func<System.Collections.Generic.IEnumerable<string>, System.Collections.Generic.IEnumerable<string>> fn) { }
-        private void RegisterEvent(System.Func<object, Mushroom.ActionArguments, System.Threading.Tasks.Task> fn) { }
-        private void RegisterEvent(System.Action<object, Mushroom.ActionArguments> fn) { }
-        private void RegisterRespondingEvent(System.Func<object, Mushroom.ActionArguments, Mushroom.ActionResult, System.Threading.Tasks.Task> fn) { }
-        private void RegisterRespondingEvent(System.Action<object, Mushroom.ActionArguments, Mushroom.ActionResult> fn) { }
-        private void RegisterJob<T>() where T : Mushroom.Job.JobBase { }
+${helperMethods}
         private void Help()
         {
 ${strDelegatorReferences}
@@ -843,20 +610,20 @@ ${strViewHandlerReferences}
 ${strVnTextChannels}
 ${strEventHandlerReferences}
 ${strJobReferences}
+${strRouteHandlers}
+${strExtensionEventHandlers}
         }
     }
 }
 #endif
 `;
-    const infoFileContent = `// Mushroom CLI version: ${packageVersion}
-// Compatible with Mushroom Server version: 0.2.25.4 or higher (https://www.nuget.org/packages/Mushroom/)
-// For Mushroom Server 0.2.18 to 0.2.25.4: Please remove all FindById methods in DbConnector.cs`;
-    fs.writeFileSync(aliasProject.output + '/DbConnector.cs', dbConnectorFileContent);
-    fs.writeFileSync(aliasProject.output + '/ResourceNames.cs', resourceNamesFileContent);
-    fs.writeFileSync(aliasProject.output + '/RoleNames.cs', roleNamesFileContent);
-    fs.writeFileSync(aliasProject.output + '/RefactorHelper.cs', refactorHelperFileContent);
-    fs.writeFileSync(aliasProject.output + '/Info.cs', infoFileContent);
-    common.logInfo(`Generated CSharp MongoDb Classes for ${projectName}@${alias} to folder ${aliasProject.output}`);
+        common.ensureFolder(aliasProject.output);
+        fs.writeFile(aliasProject.output, fullCode, (err) => {
+            if (err)
+                throw err;
+            common.logInfo(`Generated CSharp MongoDb Classes for ${projectName}@${alias} to ${aliasProject.output}`);
+        });
+    }
 }
 function generateCSharpClassDriver(source, className, fields, description, out) {
     let strClasses = '';
@@ -864,7 +631,7 @@ function generateCSharpClassDriver(source, className, fields, description, out)
     let content = '';
     if (description) {
         content += `    /// <summary>
-    /// ${singleLine(description)}
+    /// ${escapseForXmlDocs(description)}
     /// </summary>
 `;
     }
@@ -894,7 +661,7 @@ function generateCSharpClassDriver(source, className, fields, description, out)
         else
             type = getCSharpTypeFromMushroomType(source, field.type, field.validation && field.validation.required);
         content += `        /// <summary>
-        /// ${singleLine(field.description)}
+        /// ${escapseForXmlDocs(field.description)}
         /// </summary>
         [Newtonsoft.Json.JsonProperty(PropertyName ="${fieldName}", NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore${type === 'System.Datetime' ? ', DefaultValueHandling = Newtonsoft.Json.DefaultValueHandling.Ignore' : ''})]
         [System.Text.Json.Serialization.JsonPropertyName("${fieldName}")]