mushroom-cli 1.2.0-alpha.9 → 1.2.0

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

@@ -0,0 +1,600 @@
+import fs from 'fs';
+import * as common from '../common.js';
+function isAllowCache(actions, defaultValue) {
+    let result = defaultValue;
+    for (let i = 0; i < actions.length; i++) {
+        const action = actions[i];
+        if (!action ||
+            !action.cache ||
+            !action.cache.client ||
+            !action.cache.client.policy ||
+            action.cache.client.policy === 'unset')
+            continue;
+        if (action.cache.client.policy === 'disabled')
+            return false;
+        if (action.cache.client.policy === 'allow' || action.cache.client.policy === 'required')
+            result = true;
+    }
+    return result;
+}
+function toVietnameseNonTongue(str) {
+    const signText = 'ăâđêôơưàảãạáằẳẵặắầẩẫậấèẻẽẹéềểễệếìỉĩịíòỏõọóồổỗộốờởỡợớùủũụúừửữựứỳỷỹỵýĂÂĐÐÊÔƠƯÀẢÃẠÁẰẲẴẶẮẦẨẪẬẤÈẺẼẸÉỀỂỄỆẾÌỈĨỊÍÒỎÕỌÓỒỔỖỘỐỜỞỠỢỚÙỦŨỤÚỪỬỮỰỨỲỶỸỴÝ';
+    const unsignedText = 'aadeoouaaaaaaaaaaaaaaaeeeeeeeeeeiiiiiooooooooooooooouuuuuuuuuuyyyyyAADDEOOUAAAAAAAAAAAAAAAEEEEEEEEEEIIIIIOOOOOOOOOOOOOOOUUUUUUUUUUYYYYY';
+    let returnValue = '';
+    for (let i = 0; i < str.length; i++) {
+        const index = signText.indexOf(str.charAt(i));
+        returnValue += index !== -1 ? unsignedText.charAt(index) : str.charAt(i);
+    }
+    return returnValue;
+}
+function toTypeScriptClassName(str) {
+    if (!str)
+        return '_';
+    const name = toVietnameseNonTongue(str).replace(/\W/g, '_');
+    const c = name.charAt(0);
+    return ('0' <= c && c <= '9' ? '_' : '') + c.toUpperCase() + name.substring(1);
+}
+function getCSharpTypeFromMushroomType(type) {
+    switch (type) {
+        case 'string':
+            return 'string';
+        case 'boolean':
+            return 'boolean';
+        case 'integer':
+        case 'long':
+        case 'double':
+            return 'number';
+        case 'datetime':
+            return 'ISODateValue';
+        case 'IdRef':
+        case 'AutoId':
+            return 'IdValue';
+        default:
+            return 'any';
+    }
+}
+function generateDescription(description, ident = '    ') {
+    if (!description)
+        return '';
+    return `${ident}/**\n${ident} * ${description
+        .replace(/\r/g, '')
+        .split('\n')
+        .map((line) => (line.includes('*/') ? line.replace(/\*\//g, '* /') : line))
+        .join('\n' + ident + ' * ')}\n${ident} */\n`;
+}
+function generateTypescriptClass(objectDefination, className, options) {
+    let childrenCode = '';
+    let code = `export interface ${className} {\n`;
+    for (const fieldName in objectDefination) {
+        const field = objectDefination[fieldName];
+        if (!field)
+            continue;
+        code += generateDescription(field.description);
+        const optionalMark = options?.checkRequired &&
+            (field.required || field.validation?.required)
+            ? ''
+            : '?';
+        const nullType = optionalMark ? ' | null' : '';
+        if (field.type == 'object') {
+            const fieldClassName = className + '_' + toTypeScriptClassName(fieldName);
+            code += `    ${fieldName}${optionalMark}: ${fieldClassName}${nullType};\n`;
+            childrenCode += generateTypescriptClass(field.fields ?? {}, fieldClassName, options);
+        }
+        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}: 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}: 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(field.type ?? 'string')}${nullType};\n`;
+        }
+    }
+    code += '}\n\n';
+    return code + childrenCode;
+}
+function generateTypescriptClassFromViewParameters(parameters) {
+    if (Array.isArray(parameters)) {
+        return ('{\n' +
+            parameters
+                .map((p) => `${generateDescription(p.description)}    ${p.field}${p.validation?.required && p.defaultValue === undefined ? '' : '?'}: ${getCSharpTypeFromMushroomType(p.type || 'string')}${p.isArray ? '[]' : ''}${p.validation?.required && p.defaultValue === undefined ? '' : ' | null'};`)
+                .join('\n') +
+            '\n}');
+    }
+    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);
+    const inputTypes = new Set();
+    const 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) {
+            const 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 '';
+    }
+    const entities = common.getEntities(source, aliasProject.allowRoles);
+    const extensionsImportLines = [];
+    const extensionsExportLines = [];
+    const extensionsTypes = [];
+    const extensionsCodeLines = [];
+    if (Array.isArray(aliasProject.features)) {
+        if (aliasProject.features.includes('auth')) {
+            extensionsImportLines.push('import * as AuthExtension from "mushroomjs-auth";');
+            extensionsExportLines.push('File: FileExtension');
+            extensionsTypes.push('AuthExtension.IMushroomAuth & ');
+            extensionsCodeLines.push('AuthExtension.useAuth(AuthExtension.AuthLocalStorage, mushroom);');
+        }
+        if (aliasProject.features.includes('file')) {
+            extensionsImportLines.push('import * as FileExtension from "mushroomjs-file";');
+            extensionsExportLines.push('Auth: AuthExtension');
+            extensionsTypes.push('FileExtension.IMushroomFile & ');
+            extensionsCodeLines.push('FileExtension.useFile(mushroom);');
+        }
+    }
+    let code = `import mushroom, { defineAsyncResource, defineAsyncView, fireEvent, createRestfulAsyncFunction, IdType, IMushroom, Mushroom, MushroomRequest, MushroomRequestSetting, MushroomRestfulRequest, MushroomResponse, MushroomResponseDataType, MushroomResourceBase, MushroomListResource, MushroomCountResource, MushroomFindByIdResource, MushroomCreateResource, MushroomBatchCreateResource, MushroomUpdateResource, MushroomBatchUpdateResource, MushroomPartialUpdateResource, MushroomDeleteResource, MushroomBatchDeleteResource, MushroomExtensibleResource, MushroomViewFunction, MushroomError, IMushroomOfflineResponse, MushroomOfflineResponse, MushroomOfflineResponseState } from "mushroomjs";
+${extensionsImportLines.join('\n')}
+export * from "mushroomjs";
+export const extensions = {
+    ${extensionsExportLines.join(',\n    ')}
+};
+
+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) {
+        const entity = entities[entityName];
+        const typescriptClassName = toTypeScriptClassName(entityName);
+        code += generateTypescriptClass(entity.fields, typescriptClassName);
+        const actions = {};
+        iApiClassBody += generateDescription(entity.description);
+        iApiClassBody += `    ${entityName}: MushroomResourceBase`;
+        let customMethodCode = '';
+        for (const actionName in entity.actions) {
+            let clientCache = undefined;
+            let includeTotal = undefined;
+            let offlineMode = undefined;
+            if ((actionName === 'findById' || actionName === 'findMany') && entity.actions[actionName]) {
+                if (isAllowCache(entity.actions[actionName], true))
+                    clientCache = true;
+                if (actionName === 'findMany' && entity.actions[actionName].some((a) => a.includeTotal))
+                    includeTotal = true;
+                if (entity.actions[actionName].some((a) => a.offlineMode === 'disallow'))
+                    offlineMode = 'disallow';
+                else if (!entity.actions[actionName].length ||
+                    entity.actions[actionName].some((a) => a.offlineMode === 'allow'))
+                    offlineMode = 'allow';
+            }
+            actions[actionName] = {
+                clientCache,
+                includeTotal,
+                offlineMode,
+            };
+            switch (actionName) {
+                case 'findMany': {
+                    iApiClassBody += ` & MushroomListResource<${typescriptClassName}>`;
+                    if (includeTotal)
+                        iApiClassBody += ' & MushroomCountResource';
+                    break;
+                }
+                case 'findById': {
+                    iApiClassBody += ` & MushroomFindByIdResource<${typescriptClassName}>`;
+                    break;
+                }
+                case 'createOne': {
+                    iApiClassBody += ` & MushroomCreateResource<${typescriptClassName}>`;
+                    break;
+                }
+                case 'createMany': {
+                    iApiClassBody += ` & MushroomBatchCreateResource<${typescriptClassName}>`;
+                    break;
+                }
+                case 'updateOne': {
+                    iApiClassBody += ` & MushroomUpdateResource<${typescriptClassName}>`;
+                    break;
+                }
+                case 'updateMany': {
+                    iApiClassBody += ` & MushroomBatchUpdateResource<${typescriptClassName}>`;
+                    break;
+                }
+                case 'updatePartially': {
+                    iApiClassBody += ` & MushroomPartialUpdateResource<${typescriptClassName}>`;
+                    break;
+                }
+                case 'deleteOne': {
+                    iApiClassBody += ' & MushroomDeleteResource';
+                    break;
+                }
+                case 'deleteMany': {
+                    iApiClassBody += ' & MushroomBatchDeleteResource';
+                    break;
+                }
+                default: {
+                    if (actionName.indexOf('_raw_http_method_') === 0) {
+                        const customCode = generateCustomMethodCode(entityName, actionName, entity.actions[actionName]);
+                        customMethodCode += customCode.methodCode;
+                        code += customCode.classesCode;
+                        break;
+                    }
+                    else {
+                        common.logWarning(`Unknown action name: ${entityName}.${actionName}`);
+                        break;
+                    }
+                }
+            }
+        }
+        if (customMethodCode) {
+            code += `export interface ${typescriptClassName}$CustomMethodResource {\n${customMethodCode}}\n`;
+            iApiClassBody += ` & ${typescriptClassName}$CustomMethodResource`;
+        }
+        const views = {};
+        let viewCode = '';
+        for (const viewName in entity.views) {
+            const viewRoles = entity.views[viewName];
+            if (!Array.isArray(viewRoles) || !viewRoles.length)
+                continue;
+            views[viewName] = { clientCache: true };
+            const viewParameterTypes = viewRoles.map((view) => {
+                const inputType = `${typescriptClassName}$ViewsResource_${viewName}View_${view.grant === '*' ? '' : toTypeScriptClassName(view.grant)}Parameters`;
+                const outputType = view.codeHint?.output
+                    ? `${typescriptClassName}$ViewsResource_${viewName}View_${view.grant === '*' ? '' : toTypeScriptClassName(view.grant)}Result`
+                    : 'any';
+                code += `export interface ${inputType} ${generateTypescriptClassFromViewParameters(view.parameters)};
+`;
+                if (view.codeHint?.output)
+                    code += generateTypescriptClass(view.codeHint.output.fields ?? {}, outputType, { checkRequired: true });
+                return `MushroomViewFunction<${outputType}, ${inputType}>`;
+            });
+            viewCode += `
+        ${viewName}Async: ${viewParameterTypes.join(' | ')};`;
+        }
+        if (viewCode) {
+            code += `export interface ${typescriptClassName}$ViewsResource {
+    views: {${viewCode}
+    }
+}
+`;
+            iApiClassBody += ` & ${typescriptClassName}$ViewsResource`;
+        }
+        iApiClassBody += `,
+`;
+        code += `defineAsyncResource<${typescriptClassName}>(${JSON.stringify({ name: entityName, actions: actions, views: views })});
+
+`;
+    }
+    code += `
+mushroom.$using(${JSON.stringify(common.getRootUrl(source))});
+
+(function(){
+${extensionsCodeLines.join('\n')}
+})();
+
+export interface IApi extends IMushroom {
+${iApiClassBody}};
+
+export type Api = ${extensionsTypes.join('')}IApi;
+
+export default mushroom as Api;`;
+    return code;
+}
+export function genDtsString(aliasProject, source) {
+    if (!aliasProject) {
+        return '';
+    }
+    const entities = common.getEntities(source, aliasProject.allowRoles);
+    const extensionsImportLines = [];
+    const extensionsExportLines = [];
+    const extensionsTypes = [];
+    if (Array.isArray(aliasProject.features)) {
+        if (aliasProject.features.includes('auth')) {
+            extensionsImportLines.push('import * as AuthExtension from "mushroomjs-auth";');
+            extensionsExportLines.push('Auth: AuthExtension');
+            extensionsTypes.push('AuthExtension.IMushroomAuth & ');
+        }
+        if (aliasProject.features.includes('file')) {
+            extensionsImportLines.push('import * as FileExtension from "mushroomjs-file";');
+            extensionsExportLines.push('File: FileExtension');
+            extensionsTypes.push('FileExtension.IMushroomFile & ');
+        }
+    }
+    let code = `import { IdType, IMushroom, Mushroom, MushroomRequest, MushroomRequestSetting, MushroomRestfulRequest, MushroomResponse, MushroomResponseDataType, MushroomResourceBase, MushroomListResource, MushroomCountResource, MushroomFindByIdResource, MushroomCreateResource, MushroomBatchCreateResource, MushroomUpdateResource, MushroomBatchUpdateResource, MushroomPartialUpdateResource, MushroomDeleteResource, MushroomBatchDeleteResource, MushroomExtensibleResource, MushroomViewFunction, MushroomError, IMushroomOfflineResponse, MushroomOfflineResponse, MushroomOfflineResponseState } from "mushroomjs";
+${extensionsImportLines.join('\n')}
+export * from "mushroomjs";
+export declare const extensions = {
+    ${extensionsExportLines.join(',\n    ')}
+};
+
+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) {
+        const entity = entities[entityName];
+        const typescriptClassName = toTypeScriptClassName(entityName);
+        code += generateTypescriptClass(entity.fields, typescriptClassName);
+        const actions = {};
+        iApiClassBody += `    ${entityName}: MushroomResourceBase`;
+        let customMethodCode = '';
+        for (const actionName in entity.actions) {
+            let clientCache = undefined;
+            let includeTotal = undefined;
+            let offlineMode = undefined;
+            if ((actionName === 'findById' || actionName === 'findMany') && entity.actions[actionName]) {
+                if (isAllowCache(entity.actions[actionName], true))
+                    clientCache = true;
+                if (actionName === 'findMany' && entity.actions[actionName].some((a) => a.includeTotal))
+                    includeTotal = true;
+                if (entity.actions[actionName].some((a) => a.offlineMode === 'disallow'))
+                    offlineMode = 'disallow';
+                else if (!entity.actions[actionName].length ||
+                    entity.actions[actionName].some((a) => a.offlineMode === 'allow'))
+                    offlineMode = 'allow';
+            }
+            actions[actionName] = {
+                clientCache,
+                includeTotal,
+                offlineMode,
+            };
+            switch (actionName) {
+                case 'findMany': {
+                    iApiClassBody += ` & MushroomListResource<${typescriptClassName}>`;
+                    if (includeTotal)
+                        iApiClassBody += ' & MushroomCountResource';
+                    break;
+                }
+                case 'findById': {
+                    iApiClassBody += ` & MushroomFindByIdResource<${typescriptClassName}>`;
+                    break;
+                }
+                case 'createOne': {
+                    iApiClassBody += ` & MushroomCreateResource<${typescriptClassName}>`;
+                    break;
+                }
+                case 'createMany': {
+                    iApiClassBody += ` & MushroomBatchCreateResource<${typescriptClassName}>`;
+                    break;
+                }
+                case 'updateOne': {
+                    iApiClassBody += ` & MushroomUpdateResource<${typescriptClassName}>`;
+                    break;
+                }
+                case 'updateMany': {
+                    iApiClassBody += ` & MushroomBatchUpdateResource<${typescriptClassName}>`;
+                    break;
+                }
+                case 'updatePartially': {
+                    iApiClassBody += ` & MushroomPartialUpdateResource<${typescriptClassName}>`;
+                    break;
+                }
+                case 'deleteOne': {
+                    iApiClassBody += ' & MushroomDeleteResource';
+                    break;
+                }
+                case 'deleteMany': {
+                    iApiClassBody += ' & MushroomBatchDeleteResource';
+                    break;
+                }
+                default: {
+                    if (actionName.indexOf('_raw_http_method_') === 0) {
+                        customMethodCode += `    ${actionName.substring('_raw_http_method_'.length)}Async: (rawRequest: MushroomRequest) => Promise<MushroomResponse<any>>;\n`;
+                        break;
+                    }
+                    else {
+                        common.logWarning(`Unknown action name: ${entityName}.${actionName}`);
+                        break;
+                    }
+                }
+            }
+        }
+        if (customMethodCode) {
+            code += `export interface ${typescriptClassName}$CustomMethodResource {
+${customMethodCode}}
+`;
+            iApiClassBody += ` & ${typescriptClassName}$CustomMethodResource`;
+        }
+        const views = {};
+        let viewCode = '';
+        for (const viewName in entity.views) {
+            const viewRoles = entity.views[viewName];
+            if (!Array.isArray(viewRoles) || !viewRoles.length)
+                continue;
+            views[viewName] = { clientCache: true };
+            const viewParameterTypes = viewRoles.map((view) => {
+                const inputType = `${typescriptClassName}$ViewsResource_${viewName}View_${view.grant === '*' ? '' : toTypeScriptClassName(view.grant)}Parameters`;
+                const outputType = view.codeHint?.output
+                    ? `${typescriptClassName}$ViewsResource_${viewName}View_${view.grant === '*' ? '' : toTypeScriptClassName(view.grant)}Result`
+                    : 'any';
+                code += `export interface ${inputType} ${generateTypescriptClassFromViewParameters(view.parameters)};\n`;
+                if (view.codeHint?.output)
+                    code += generateTypescriptClass(view.codeHint.output.fields ?? {}, outputType, { checkRequired: true });
+                return `MushroomViewFunction<${outputType}, ${inputType}>`;
+            });
+            viewCode += `
+        ${viewName}Async: ${viewParameterTypes.join(' | ')},`;
+        }
+        if (viewCode) {
+            code += `export interface ${typescriptClassName}$ViewsResource {
+    views: {${viewCode}
+    }
+}
+`;
+            iApiClassBody += ` & ${typescriptClassName}$ViewsResource`;
+        }
+        iApiClassBody += `,
+`;
+    }
+    code += `
+export interface IApi extends IMushroom {
+${iApiClassBody}};
+
+declare type Api = ${extensionsTypes.join('')}IApi;
+declare const _default: Api;
+export default _default;`;
+    return code;
+}
+export function genTypescriptDriver(args, projectName, project, alias, source) {
+    const aliasProject = ((project.tsDriver || {}).alias || {})[alias];
+    if (!aliasProject) {
+        throw new Error(`Not found gen ts-driver configuration. Please run 'npx mushroom-cli config gen ${projectName} ts-driver OUTPUT_FILE.ts${alias === 'default' ? '' : ' alias ' + alias}' first`);
+    }
+    const code = genTypescriptDriverString(aliasProject, source);
+    common.ensureFolder(aliasProject.output);
+    fs.writeFileSync(aliasProject.output, code);
+    common.logInfo(`Generated Typescript driver for ${projectName}@${alias} to ${aliasProject.output}`);
+}