mushroom-cli 1.2.0-alpha.18 → 1.2.0-alpha.19

package/README.md

@@ -132,6 +132,14 @@ npx mushroom-cli parameters --no-check-update
 
 ## Version
 
+### 1.2.0-alpha.19
+
+Improvement:
+
+- gen-ts:
+  - generate type for custom methods of action
+  - generate description for fields, entities
+
 ### 1.2.0-alpha.17
 
 Improvement:

package/dist/gen/gen-ts-driver.js

@@ -38,9 +38,6 @@ function getCSharpTypeFromMushroomType(type) {
     switch (type) {
         case 'string':
             return 'string';
-        case 'object':
-        case 'array':
-            return '';
         case 'boolean':
             return 'boolean';
         case 'integer':
@@ -52,32 +49,73 @@ function getCSharpTypeFromMushroomType(type) {
         case 'IdRef':
         case 'AutoId':
             return 'IdValue';
+        default:
+            return 'any';
     }
-    return 'UNKNOWN_TYPE_' + type;
 }
 function generateTypescriptClass(objectDefination, className, options) {
     let childrenCode = '';
     let code = `export interface ${className} {\n`;
     for (const fieldName in objectDefination) {
-        const optionalMark = options?.checkRequired && objectDefination[fieldName].required ? '' : '?';
+        const field = objectDefination[fieldName];
+        if (!field)
+            continue;
+        if (field.description) {
+            code += `    /**\n     * ${field.description.replace(/\r/, '').split('\n').map(line => line.includes('*/') ? line.replace(/\*\//g, "* /") : line).join('\n     * ')}\n     */\n`;
+        }
+        const optionalMark = options?.checkRequired && (field.required || field.validation?.required) ? '' : '?';
         const nullType = optionalMark ? ' | null' : '';
-        if (objectDefination[fieldName].type == 'object') {
+        if (field.type == 'object') {
             const fieldClassName = className + '_' + toTypeScriptClassName(fieldName);
             code += `    ${fieldName}${optionalMark}: ${fieldClassName}${nullType};\n`;
-            childrenCode += generateTypescriptClass(objectDefination[fieldName].fields ?? {}, fieldClassName);
+            childrenCode += generateTypescriptClass(field.fields ?? {}, fieldClassName, options);
         }
-        else if (objectDefination[fieldName].type == 'array') {
-            if (objectDefination[fieldName].items?.type == 'object') {
+        else if (field.type == 'keyValue') {
+            const valueNullType = options?.checkRequired && (field.values.required || field.values.validation?.required) ? '' : ' | null | undefined';
+            if (field.values?.type == 'object') {
                 const fieldClassName = className + '_' + toTypeScriptClassName(fieldName);
-                code += `    ${fieldName}${optionalMark}: ${fieldClassName}[]${nullType};\n`;
-                childrenCode += generateTypescriptClass(objectDefination[fieldName].items?.fields ?? {}, fieldClassName);
+                code += `    ${fieldName}${optionalMark}: Record<string, ${fieldClassName}${valueNullType}>${nullType};\n`;
+                childrenCode += generateTypescriptClass(field.values.fields ?? {}, fieldClassName, options);
+            }
+            else if (field.values?.type == 'array') {
+                const itemNullType = options?.checkRequired && (field.values.items?.required || field.values.items?.validation?.required) ? '' : ' | null | undefined';
+                if (field.values.items?.type == 'object') {
+                    const fieldClassName = className + '_' + toTypeScriptClassName(fieldName);
+                    code += `    ${fieldName}${optionalMark}: Record<string, Array<${fieldClassName}${itemNullType}>${valueNullType}>${nullType};\n`;
+                    childrenCode += generateTypescriptClass(field.values.items.fields ?? {}, fieldClassName, options);
+                }
+                else {
+                    code += `    ${fieldName}${optionalMark}: Record<string, Array<${getCSharpTypeFromMushroomType(field.values.items?.type ?? 'string')}${itemNullType}>${valueNullType}>${nullType};\n`;
+                }
             }
             else {
-                code += `    ${fieldName}${optionalMark}: ${getCSharpTypeFromMushroomType(objectDefination[fieldName].items?.type ?? '')}[]${nullType};\n`;
+                code += `    ${fieldName}${optionalMark}: Record<string, ${getCSharpTypeFromMushroomType(field.values?.type ?? 'string')}${valueNullType}>${nullType};\n`;
+            }
+        }
+        else if (field.type == 'array') {
+            const itemNullType = options?.checkRequired && (field.items.required || field.items.validation?.required) ? '' : ' | null | undefined';
+            if (field.items?.type == 'object') {
+                const fieldClassName = className + '_' + toTypeScriptClassName(fieldName);
+                code += `    ${fieldName}${optionalMark}: Array<${fieldClassName}${itemNullType}>${nullType};\n`;
+                childrenCode += generateTypescriptClass(field.items.fields ?? {}, fieldClassName, options);
+            }
+            else if (field.items?.type == 'keyValue') {
+                const valueNullType = options?.checkRequired && (field.items.values?.required || field.items.values?.validation?.required) ? '' : ' | null | undefined';
+                if (field.items.values?.type == 'object') {
+                    const fieldClassName = className + '_' + toTypeScriptClassName(fieldName);
+                    code += `    ${fieldName}${optionalMark}: Array<Record<string, ${fieldClassName}${valueNullType}>${itemNullType}>${nullType};\n`;
+                    childrenCode += generateTypescriptClass(field.items.values.fields ?? {}, fieldClassName, options);
+                }
+                else {
+                    code += `    ${fieldName}${optionalMark}: Array<Record<string, ${getCSharpTypeFromMushroomType(field.items.type ?? 'string')}${valueNullType}>${itemNullType}>${nullType};\n`;
+                }
+            }
+            else {
+                code += `    ${fieldName}${optionalMark}: Array<${getCSharpTypeFromMushroomType(field.items?.type ?? 'string')}${itemNullType}>${nullType};\n`;
             }
         }
         else {
-            code += `    ${fieldName}${optionalMark}: ${getCSharpTypeFromMushroomType(objectDefination[fieldName].type)}${nullType};\n`;
+            code += `    ${fieldName}${optionalMark}: ${getCSharpTypeFromMushroomType(field.type ?? 'string')}${nullType};\n`;
         }
     }
     code += '}\n\n';
@@ -93,6 +131,69 @@ function generateTypescriptClassFromViewParameters(parameters) {
     }
     return '{}';
 }
+function generateTopCustomClass(config, entityName, methodName, grantRole, postfix, code) {
+    const isKeyValue = config.type == 'keyValue';
+    const isArray = isKeyValue ? config.values?.type == 'array' : config.type == 'array';
+    const fields = isKeyValue ? (isArray ? config.values?.items?.fields : config.values?.fields) : (isArray ? config.items?.fields : config.fields);
+    const type = (isKeyValue ? (isArray ? config.values?.items?.type : config.values?.type) : (isArray ? config.items?.type : config.type)) ?? 'string';
+    let inputClassName;
+    if (type == 'object') {
+        if (fields) {
+            const roleIndicator = grantRole ? '_' + toTypeScriptClassName(grantRole) + '_' : '';
+            inputClassName = `${toTypeScriptClassName(entityName)}_${toTypeScriptClassName(methodName)}${roleIndicator}${postfix}`;
+            code.classesCode += generateTypescriptClass(fields, inputClassName, {
+                checkRequired: true
+            });
+        }
+        else {
+            inputClassName = 'any';
+        }
+    }
+    else
+        inputClassName = getCSharpTypeFromMushroomType(type);
+    return isKeyValue ? (isArray ? 'Record<string, ' + inputClassName + '[]>' : 'Record<string, ' + inputClassName + '>') : (isArray ? inputClassName + '[]' : inputClassName);
+}
+function generateCustomMethodCode(entityName, actionName, actions) {
+    const result = { classesCode: '', methodCode: '' };
+    if (!actionName || !actionName.startsWith('_raw_http_method_') || !actions || !actions.length)
+        return result;
+    actions = actions.filter(action => action.enabled);
+    if (!actions.length)
+        return result;
+    const methodName = actionName.substring('_raw_http_method_'.length);
+    let inputTypes = new Set();
+    let outputTypes = new Set();
+    actions.forEach(action => {
+        const codeHintDelegator = action?.codeHint?.delegator;
+        if (!codeHintDelegator)
+            return;
+        if (codeHintDelegator.result && !codeHintDelegator.isBinaryResponse) {
+            const className = generateTopCustomClass(codeHintDelegator.result, entityName, methodName, actions.length > 1 ? action.grant : '', 'Result', result);
+            outputTypes.add(className);
+        }
+        else {
+            outputTypes.add('any');
+        }
+        if (codeHintDelegator.param && codeHintDelegator.requestBody) {
+            let paramClassName = generateTopCustomClass(codeHintDelegator.param, entityName, methodName, actions.length > 1 ? action.grant : '', 'ParamRequest', result);
+            const bodyClassName = generateTopCustomClass(codeHintDelegator.requestBody, entityName, methodName, actions.length > 1 ? action.grant : '', 'Request', result);
+            inputTypes.add(`CustomMethodRequest<${paramClassName}, ${bodyClassName}>`);
+        }
+        else if (codeHintDelegator.param) {
+            const className = generateTopCustomClass(codeHintDelegator.param, entityName, methodName, actions.length > 1 ? action.grant : '', 'ParamRequest', result);
+            inputTypes.add(`CustomMethodParamsRequest<${className}>`);
+        }
+        else if (codeHintDelegator.requestBody) {
+            const className = generateTopCustomClass(codeHintDelegator.requestBody, entityName, methodName, actions.length > 1 ? action.grant : '', 'Request', result);
+            inputTypes.add(`CustomMethodBodyRequest<${className}>`);
+        }
+        else {
+            inputTypes.add('MushroomRequest');
+        }
+    });
+    result.methodCode = `    ${methodName}Async: (request: ${inputTypes.size ? [...inputTypes].join(' | ') : 'MushroomRequest'}) => Promise<MushroomResponse<${outputTypes.size ? [...outputTypes].join(' | ') : 'any'}>>;\n`;
+    return result;
+}
 export function genTypescriptDriverString(aliasProject, source) {
     if (!aliasProject) {
         return '';
@@ -126,6 +227,19 @@ export const extensions = {
 export type ISODateValue = string | Date;
 export type IdValue = ${source.idType == 'AutoIncInt' || source.idType == 'AutoIncLong' ? 'number' : 'string'};
 
+export interface CustomMethodRequest<TParam extends {}, TBody> extends MushroomRequest {
+  params?: TParam;
+  body?: TBody;
+}
+
+export interface CustomMethodParamsRequest<TParam extends {}> extends MushroomRequest {
+  params?: TParam;
+}
+
+export interface CustomMethodBodyRequest<TBody> extends MushroomRequest {
+  body?: TBody;
+}
+
 `;
     let iApiClassBody = '';
     for (const entityName in entities) {
@@ -133,6 +247,9 @@ export type IdValue = ${source.idType == 'AutoIncInt' || source.idType == 'AutoI
         const typescriptClassName = toTypeScriptClassName(entityName);
         code += generateTypescriptClass(entity.fields, typescriptClassName);
         const actions = {};
+        if (entity.description) {
+            iApiClassBody += `    /**\n     * ${entity.description.replace(/\r/, '').split('\n').map(line => line.includes('*/') ? line.replace(/\*\//g, "* /") : line).join('\n     * ')}\n     */\n`;
+        }
         iApiClassBody += `    ${entityName}: MushroomResourceBase`;
         let customMethodCode = '';
         for (const actionName in entity.actions) {
@@ -194,7 +311,9 @@ export type IdValue = ${source.idType == 'AutoIncInt' || source.idType == 'AutoI
                 }
                 default: {
                     if (actionName.indexOf('_raw_http_method_') === 0) {
-                        customMethodCode += `    ${actionName.substring('_raw_http_method_'.length)}Async: (rawRequest: MushroomRequest) => Promise<MushroomResponse<any>>;\n`;
+                        const customCode = generateCustomMethodCode(entityName, actionName, entity.actions[actionName]);
+                        customMethodCode += customCode.methodCode;
+                        code += customCode.classesCode;
                         break;
                     }
                     else {
@@ -205,9 +324,7 @@ export type IdValue = ${source.idType == 'AutoIncInt' || source.idType == 'AutoI
             }
         }
         if (customMethodCode) {
-            code += `export interface ${typescriptClassName}$CustomMethodResource {
-${customMethodCode}}
-`;
+            code += `export interface ${typescriptClassName}$CustomMethodResource {\n${customMethodCode}}\n`;
             iApiClassBody += ` & ${typescriptClassName}$CustomMethodResource`;
         }
         const views = {};
@@ -290,6 +407,19 @@ export declare const extensions = {
 export declare type ISODateValue = string | Date;
 export declare type IdValue = ${source.idType == 'AutoIncInt' || source.idType == 'AutoIncLong' ? 'number' : 'string'};
 
+export interface CustomMethodRequest<TParam extends {}, TBody> extends MushroomRequest {
+  params?: TParam;
+  body?: TBody;
+}
+
+export interface CustomMethodParamsRequest<TParam extends {}> extends MushroomRequest {
+  params?: TParam;
+}
+
+export interface CustomMethodBodyRequest<TBody> extends MushroomRequest {
+  body?: TBody;
+}
+
 `;
     let iApiClassBody = '';
     for (const entityName in entities) {

package/package.json

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