mushroom-cli 1.0.15 → 1.1.0-alpha.10

package/README.md

@@ -24,7 +24,11 @@ Config gen database docs
 
 Config gen javascript driver
 
-    npx mr config gen projectName js-driver ./src/api/mushroom.api.js [alias aliasName] [roles Admin,User-Contributor]
+    npx mr config gen projectName js-driver ./src/api/mushroom.api.js [alias aliasName] [roles Admin,User-Contributor] [tarball tarballName]
+
+Config gen typescript driver
+
+    npx mr config gen projectName ts-driver ./src/api/mushroom.api.ts [alias aliasName] [roles Admin,User-Contributor]
 
 Config gen entities for Mushroom project in CSharp and using MongoDb
 
@@ -44,10 +48,18 @@ Generate database docs (html format)
 
     npx mr gen projectName[@aliasName] db-docs [tmp]
 
+Generate npm package (tarball file)
+
+    npx mr gen projectName[@aliasName] js-driver-tarball
+
 Generate javascript driver
 
     npx mr gen projectName[@aliasName] js-driver
 
+Generate typescript driver
+
+    npx mr gen projectName[@aliasName] ts-driver
+
 Generate entities for Mushroom project in CSharp and using MongoDb
 
     npx mr gen projectName[@aliasName] c#-mongo

package/check-update.js

@@ -2,7 +2,7 @@ const fetch = require('node-fetch');
 
 
 function checkUpdate() {
-    return fetch('https://registry.npmjs.org/mushroom-cli/latest')
+    return fetch('https://registry.npmjs.org/mushroom-cli/')
         .then(res => res.json());
 }
 

package/config.js

@@ -165,6 +165,7 @@ function configGenJavascriptDriver(args, mushroomConfig, projectName){
         denyRoles: []
     };
     let alias = "default";
+    let tarball = undefined;
     while (index < args.length) {
         switch (args[index]) {
             case "roles":
@@ -187,6 +188,12 @@ function configGenJavascriptDriver(args, mushroomConfig, projectName){
                 if (strAlias)
                     alias = strAlias;
                 break;
+            case "tarball":
+                index++;
+                const strTarball = args[index];
+                if (strTarball)
+                    tarball = strTarball;
+                break;
         }
         index++;
     }
@@ -201,6 +208,7 @@ function configGenJavascriptDriver(args, mushroomConfig, projectName){
             projectAlias[key] = value;
         }
     }
+    projectAlias.tarballName = tarball;
     projectAlias.output = path;
     saveConfig(mushroomConfig, () => console.log(`Saved configuration of gen javascript driver for ${projectName}@${alias}`));
 }

package/gen/gen-api-docs.js

@@ -9,6 +9,8 @@ function processGenDocs(aliasProject, entities, source, html, args, projectName,
     console.log('Received html');
     console.log("Parsing html");
 
+    const roles = aliasProject.allowRoles.includes("*") ? source.roles : source.roles?.filter(r => aliasProject.allowRoles.includes(r.name));
+    
     html = html.replace(/^\uFEFF/, '');
     html = html.replace(/<script src=(["'])\/\//g, "<script src=$1http://");
     html = html.replace("</body>", `<script data-mt-cond='{"x": 1}'>
@@ -16,9 +18,11 @@ function processGenDocs(aliasProject, entities, source, html, args, projectName,
     window.data.description = ${JSON.stringify(source.description)};
     window.data.rootUrl = ${JSON.stringify(common.getRootUrl(source))};
     window.data.environmentVariables = ${JSON.stringify(source.environmentVariables)};
+    window.data.roles = ${JSON.stringify(roles)};
     window.data.entities = ${JSON.stringify(entities)};
     window.data.features = ${JSON.stringify(aliasProject.features)};
-    try{
+    try {
+        console.info("MUSHROOM-CLI: START");
         window.generateDocument();
         console.info("MUSHROOM-CLI: FINISH");
     }
@@ -31,6 +35,12 @@ function processGenDocs(aliasProject, entities, source, html, args, projectName,
     return new Promise((resolve, reject) => {
         const virtualConsole = new jsdom.VirtualConsole();
         virtualConsole.on("info", function(msg, err) {
+            if (typeof msg != "string") return;
+
+            if (msg.indexOf("MUSHROOM-CLI:") === 0) {
+                console.log("GenDocEngine:" + msg.substr("MUSHROOM-CLI:".length));
+            }
+
             if (msg === "MUSHROOM-CLI: FAIL"){
                 dom = null;
                 reject(err);
@@ -97,6 +107,16 @@ async function genDocs(args, projectName, project, alias, source) {
 
     const entities = common.getEntities(source, aliasProject.allowRoles);
 
+    if (Array.isArray(aliasProject.entities)) {
+        for (const entityName in entities) {
+            if (Object.hasOwnProperty.call(entities, entityName)) {
+                if (aliasProject.entities.every(re => !new RegExp(re).test(entityName))){
+                    delete entities[entityName];
+                }
+            }
+        }
+    }
+
     console.log('Fetching https://api.siten.vn/gen/docs.html');
     const html = await fetch('https://api.siten.vn/gen/docs.html').then(res => res.text());
     await processGenDocs(aliasProject, entities, source, html, args, projectName, alias);

package/gen/gen-csharp.js

@@ -1,5 +1,6 @@
 const fs = require("fs");
 const common = require("../common.js");
+const package = require("./../package.json");
 
 //#region shared function
 function singleLine(str) {
@@ -145,8 +146,17 @@ function generateCSharpClassMongoDb(source, className, fields, isRoot, descripti
     /// </summary>\r\n`;
     }
     var supperClass = "";
-    if (isRoot)
-        supperClass = " : Resource<" + getCSharpTypeFromMushroomType(source, fields.id ? fields.id.type : "AutoId", true) + ">";
+    if (isRoot) {
+        // thêm cho trường hợp không khai báo id hoặc id.type
+        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 class ${className}${supperClass}
     {
 `;
@@ -385,9 +395,9 @@ function genCSharpMongoDbClasses(args, projectName, project, alias, source) {
             .join("\r\n")
         : "";
 
-    const code = `// This file was generated by Mushroom CLI (https://www.npmjs.com/package/mushroom-cli), please do not modify
+    const code = `// This file was generated by Mushroom CLI ${package.version} (https://www.npmjs.com/package/mushroom-cli), please do not modify
 
-// NOTE: Compatible with Mushroom Server version 0.2.15 or higher
+// NOTE: Compatible with Mushroom Server version 0.2.18 or higher
 
 // ReSharper disable RedundantUsingDirective
 // ReSharper disable InconsistentNaming
@@ -413,17 +423,17 @@ namespace ${namespace}
 ${collectionNames}
         public static IMongoDatabase GetDatabase() => Mushroom.MushroomDaoFactory.GetDbAdapter() as IMongoDatabase;
         
-        public static async System.Threading.Tasks.Task<T> FindByIdAsync<T, TId>(this IMongoCollection<T> collection, TId id) where T : Resource<TId>
+        public static async System.Threading.Tasks.Task<T> FindByIdAsync<T, TId>(this IMongoCollection<T> collection, TId id) where T : Mushroom.Models.IResource<TId>
         {
             return await (await collection.FindAsync(Builders<T>.Filter.Eq(doc => doc.Id, id))).FirstOrDefaultAsync();
         }
         
-        public static async System.Threading.Tasks.Task<T> FindByIdAsync<T, TId>(this IMongoCollection<T> collection, TId id, FindOptions<T> findOptions) where T : Resource<TId>
+        public static async System.Threading.Tasks.Task<T> FindByIdAsync<T, TId>(this IMongoCollection<T> collection, TId id, FindOptions<T> findOptions) where T : Mushroom.Models.IResource<TId>
         {
             return await (await collection.FindAsync(Builders<T>.Filter.Eq(doc => doc.Id, id), findOptions)).FirstOrDefaultAsync();
         }
         
-        public static async System.Threading.Tasks.Task<T> FindByIdAsync<T, TId>(this IMongoCollection<T> collection, TId id, ProjectionDefinition<T> projection) where T : Resource<TId>
+        public static async System.Threading.Tasks.Task<T> FindByIdAsync<T, TId>(this IMongoCollection<T> collection, TId id, ProjectionDefinition<T> projection) where T : Mushroom.Models.IResource<TId>
         {
             return await (await collection.FindAsync(Builders<T>.Filter.Eq(doc => doc.Id, id), new FindOptions<T> { Projection = projection })).FirstOrDefaultAsync();
         }
@@ -433,11 +443,6 @@ ${collectionNames}
     {
 ${resourceNames}
     }
-
-    public interface Resource<T>
-    {
-        public T Id { get; set; }
-    }
 }
 
 namespace ${namespace}.Resources
@@ -905,11 +910,8 @@ ${strEnumClasses}
 
     common.ensureFolder(aliasProject.output);
 
-    fs.writeFile(aliasProject.output, code, err => {
-        if (err)
-            throw err;
-        console.log(`Generated CSharp Driver for ${projectName}@${alias} to ${aliasProject.output}`);
-    });
+    fs.writeFileSync(aliasProject.output, code);
+    console.log(`Generated CSharp Driver for ${projectName}@${alias} to ${aliasProject.output}`);
 }
 //#endregion
 

package/gen/gen-db-docs.js

@@ -83,7 +83,7 @@ function getMongoTableDocs(valTable) {
             <tr>
                 <td valign="top">${keyField}</td>
                 <td valign="top">${isArray ? "array of " + valField.items.type : valField.type}</td>
-                <td valign="top">${getConstrains(valField)}</td>
+                <td valign="top">${getConstrains(valField)}${isArray ? "<hr/>Array items:<br/>" + getConstrains(valField.items) : ""}</td>
                 <td valign="top" style="word-break: break-word">${encodeHtml(valField.description)}</td>
             </tr>`;
         }
@@ -115,6 +115,7 @@ function getMongoDbDocs(entities, source) {
         * {box-sizing: border-box}
         html, body {margin: 0 0; padding: 0 0; font-family: Calibri, 'helvetica neue', Arial, serifs}
         h2{background-color: #ccc;margin: 30px -20px 0;padding: 5px 10px;}
+        hr{border-width: 0; border-top: 1px solid #ccc;}
         table {border-collapse: collapse;margin-top: 5px;}
         th{background-color: #d7d7d7}
         a{color: #000; text-decoration: none}
@@ -214,11 +215,8 @@ function genDatabaseDocs(args, projectName, project, alias, source) {
 
     common.ensureFolder(aliasProject.output);
 
-    fs.writeFile(aliasProject.output, code, err => {
-        if (err)
-            throw err;
-        console.log(`Generated Database docs for ${projectName}@${alias} to ${aliasProject.output}`);
-    });
+    fs.writeFileSync(aliasProject.output, code);
+    console.log(`Generated Database docs for ${projectName}@${alias} to ${aliasProject.output}`);
 }
 
 module.exports = genDatabaseDocs;

package/gen/gen-js-driver-tarball.js

@@ -0,0 +1,99 @@
+const fs = require("fs");
+const path = require('path');
+var targz = require('targz');
+const javascriptDriverGenerator = require("./gen-js-driver");
+const typescriptDriverGenerator = require("./gen-ts-driver");
+const package = require("./../package.json");
+
+function compressAsync(src, dest, folderName) {
+    return new Promise((resolve, reject) => {
+        const options = {
+            src: src,
+            dest: dest
+        };
+        if (folderName) {
+            options.tar = {
+                map: (header) => {
+                    if (header.name === ".") return header;
+                    header.name = folderName + '/' + header.name;
+                    return header;
+                }
+            };
+        }
+
+        targz.compress(options, function(err){
+            if(err) {
+                reject(err);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+
+async function genJavascriptDriverTarball(args, projectName, project, alias, source) {
+    const aliasProject = ((project.jsDriver || {}).alias || {})[alias];
+
+    let tarballName = aliasProject.tarballName ? aliasProject.tarballName : projectName;
+    tarballName = tarballName.toLowerCase().replace(/[^a-z-]/g, "-");
+
+    const dirPath = path.join(path.dirname(aliasProject.output), tarballName);
+
+    const versionGroup = package.version.match(/([^-]+)(-(\w+).*)?/);
+    const currentDistTag = versionGroup[3] ? versionGroup[3] : "latest";
+
+    const dependencies = [`"mushroomjs": "${currentDistTag}"`];
+    if (Array.isArray(aliasProject.features) && aliasProject.features.includes("auth")) {
+        dependencies.push(`"mushroomjs-auth": "${currentDistTag}"`);
+    }
+    if (Array.isArray(aliasProject.features) && aliasProject.features.includes("file")) {
+        dependencies.push(`"mushroomjs-file": "${currentDistTag}"`);
+    }
+    
+    const packageContent = `{
+    "version": "1.0.${new Date().getTime()}",
+    "name": "${tarballName}",
+    "private": true,
+    "main": "${tarballName}.js",
+    "types": "${tarballName}.d.ts",
+    "dependencies": {
+        ${dependencies.join(',\n        ')}
+    }
+}`;
+
+    if (fs.existsSync(dirPath)) {
+        console.log("Clean up tarball folder");
+        fs.rmdirSync(dirPath, { recursive: true });
+    }
+
+    const tarballFileName = path.join(path.dirname(aliasProject.output), tarballName + ".tar.gz");
+
+    if (fs.existsSync(tarballFileName)) {
+        console.log("Clean up old tarball file");
+        fs.unlinkSync(tarballFileName);
+    }
+
+    console.log("Creating tarball folder");
+
+    fs.mkdirSync(dirPath, { recursive: true, mode: 0755 });
+
+    console.log("Generating main file: " + tarballName + ".js");
+    let code = javascriptDriverGenerator.genJavascriptDriverString(aliasProject, source);
+    fs.writeFileSync(path.join(dirPath, tarballName + ".js"), code);
+    
+    console.log("Generating types file: " + tarballName + ".d.ts");
+    code = typescriptDriverGenerator.genDtsString(aliasProject, source);
+    fs.writeFileSync(path.join(dirPath, tarballName + ".d.ts"), code);
+
+    console.log("Generating package file: package.json");
+    fs.writeFileSync(path.join(dirPath, "package.json"), packageContent);
+   
+    console.log("Generating tarball file: " + tarballFileName);
+    await compressAsync(dirPath, tarballFileName, tarballName);
+
+    console.log("Generated tarball file");
+    fs.rmdirSync(dirPath, { recursive: true });
+    console.log("Cleaned up tarball folder");
+}
+
+module.exports = genJavascriptDriverTarball;

package/gen/gen-js-driver.js

@@ -1,5 +1,6 @@
 const fs = require("fs");
 const common = require("../common.js");
+const typescriptDriverGenerator = require("./gen-ts-driver");
 
 function isAllowCache(actions, defaultValue) {
     let result = defaultValue;
@@ -22,21 +23,38 @@ function isAllowCache(actions, defaultValue) {
     return result;
 }
 
-function genJavascriptDriver(args, projectName, project, alias, source) {
-    const aliasProject = ((project.jsDriver || {}).alias || {})[alias];
-
+function genJavascriptDriverString(aliasProject, source) {
     if (!aliasProject) {
-        throw new Error(`Not found gen js-driver configuration. Please run 'npx mr config gen ${projectName} js-driver OUTPUT_FILE.js${alias === "default" ? "" : " alias " + alias}' first`);
+        return "";
     }
 
     const entities = common.getEntities(source, aliasProject.allowRoles);
 
-    let code = `import mushroom from "mushroomjs";
+    let extensionsImportLines = [];
+    let extensionsExportLines = [];
+    let extensionsCodeLines = [];
 
-"use strict";
+    if (Array.isArray(aliasProject.features)) {
+        if (aliasProject.features.includes("auth")) {
+            extensionsImportLines.push('import * as AuthExtension from "mushroomjs-auth";');
+            extensionsExportLines.push('Auth: AuthExtension');
+            extensionsCodeLines.push("AuthExtension.useAuth(AuthExtension.AuthLocalStorage);");
+        }
+        if (aliasProject.features.includes("file")) {
+            extensionsImportLines.push('import * as FileExtension from "mushroomjs-file";');
+            extensionsExportLines.push('File: FileExtension');
+            extensionsCodeLines.push("FileExtension.useFile();");
+        }
+    }
 
+    let code = `import mushroom, {defineAsyncResource} from "mushroomjs";
+export * from "mushroomjs";
+${extensionsImportLines.join("\n")}
+export const extensions = {
+    ${extensionsExportLines.join(",\n    ")}
+};
 
-const rootApiUrl = ${JSON.stringify(common.getRootUrl(source))};
+"use strict";
 
 `;
     for (let entityName in entities) {
@@ -62,19 +80,41 @@ const rootApiUrl = ${JSON.stringify(common.getRootUrl(source))};
 
             views[viewName] = {};
         }
-        code += `mushroom._defineAsyncResource({name:${JSON.stringify(entityName)},actions:${JSON.stringify(actions)},views:${JSON.stringify(views)}});
+        code += `defineAsyncResource({name:${JSON.stringify(entityName)},actions:${JSON.stringify(actions)},views:${JSON.stringify(views)}});
 `;
     }
     code += `
-mushroom.$using(rootApiUrl);`;
+mushroom.$using(${JSON.stringify(common.getRootUrl(source))});
+
+${extensionsCodeLines.join('\n')}
+
+export default mushroom;`;
+
+    return code;
+}
+
+function genJavascriptDriver(args, projectName, project, alias, source) {
+    const aliasProject = ((project.jsDriver || {}).alias || {})[alias];
+
+    if (!aliasProject) {
+        throw new Error(`Not found gen js-driver configuration. Please run 'npx mr config gen ${projectName} js-driver OUTPUT_FILE.js${alias === "default" ? "" : " alias " + alias}' first`);
+    }
+
+    let code = genJavascriptDriverString(aliasProject, source);
 
     common.ensureFolder(aliasProject.output);
 
-    fs.writeFile(aliasProject.output, code, err => {
-        if (err)
-            throw err;
-        console.log(`Generated Javascript driver for ${projectName}@${alias} to ${aliasProject.output}`);
-    });
+    fs.writeFileSync(aliasProject.output, code);
+    console.log(`Generated ${aliasProject.output}`);
+
+    code = typescriptDriverGenerator.genDtsString(aliasProject, source);
+    const dtsFilePath = aliasProject.output.replace(/\.js$/i, ".d.ts");
+    fs.writeFileSync(dtsFilePath, code);
+    console.log(`Generated ${dtsFilePath}`);
+    console.log(`Generated Javascript driver for ${projectName}@${alias}`);
 }
 
-module.exports = genJavascriptDriver;
+module.exports = {
+    genJavascriptDriver,
+    genJavascriptDriverString
+};

package/gen/gen-ts-driver.js

@@ -90,32 +90,65 @@ function generateTypescriptClass(objectDefination, indent) {
     return code;
 }
 
-function genTypescriptDriver(args, projectName, project, alias, source) {
-    const aliasProject = ((project.tsDriver || {}).alias || {})[alias];
+function generateTypescriptClassFromViewParameters(parameters) {
+    if (Array.isArray(parameters)){
+        return '{\n' + parameters.map(p => `    ${p.field}?: ${getCSharpTypeFromMushroomType(p.type || "string")}${p.isArray ? "[]" : ""}`).join(',\n') + '\n}';
+    }
+    return '{}';
+}
 
+function genTypescriptDriverString(aliasProject, source) {
     if (!aliasProject) {
-        throw new Error(`Not found gen ts-driver configuration. Please run 'npx mr config gen ${projectName} ts-driver OUTPUT_FILE.ts${alias === "default" ? "" : " alias " + alias}' first`);
+        return "";
     }
 
     const entities = common.getEntities(source, aliasProject.allowRoles);
 
-    let code = `import mushroom, { defineAsyncResource, defineAsyncView, fireEvent, createRestfulAsyncFunction, IdType, IMushroom, Mushroom, MushroomRequest, MushroomRequestSetting, MushroomRestfulRequest, MushroomResponse, MushroomResourceBase, MushroomListResource, MushroomFindByIdResource, MushroomCreateResource, MushroomBatchCreateResource, MushroomUpdateResource, MushroomBatchUpdateResource, MushroomPartialUpdateResource, MushroomDeleteResource, MushroomBatchDeleteResource, MushroomExtensibleResource, MushroomError } from "mushroomjs";
+    let extensionsImportLines = [];
+    let extensionsExportLines = [];
+    let extensionsTypes = [];
+    let 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);");
+        }
+        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();");
+        }
+    }
+
+    let code = `import mushroom, { defineAsyncResource, defineAsyncView, fireEvent, createRestfulAsyncFunction, IdType, IMushroom, Mushroom, MushroomRequest, MushroomRequestSetting, MushroomRestfulRequest, MushroomResponse, MushroomResourceBase, MushroomListResource, MushroomFindByIdResource, MushroomCreateResource, MushroomBatchCreateResource, MushroomUpdateResource, MushroomBatchUpdateResource, MushroomPartialUpdateResource, MushroomDeleteResource, MushroomBatchDeleteResource, MushroomExtensibleResource, MushroomViewFunction, MushroomError } from "mushroomjs";
+export * from "mushroomjs";
+${extensionsImportLines.join("\n")}
+export const extensions = {
+    ${extensionsExportLines.join(",\n    ")}
+};
 
 export type ISODateValue = string | Date;
 export type IdValue = ${source.idType == "AutoIncInt" || source.idType == "AutoIncLong" ? "number" : "string"};
 
 `;
+    let iApiClassBody = "";
     for (let entityName in entities) {
         if (!entities.hasOwnProperty(entityName))
             continue;
 
         const entity = entities[entityName];
-
-        code += `interface ${toTypeScriptClassName(entityName)} ${generateTypescriptClass(entity.fields)}
+        const typescriptClassName = toTypeScriptClassName(entityName);
+        code += `export interface ${typescriptClassName} ${generateTypescriptClass(entity.fields)};
 `;
 
 
         const actions = {};
+        iApiClassBody += `    ${entityName}: MushroomResourceBase`;
+        let customMethodCode = "";
         for (const actionName in entity.actions) {
             if (!entity.actions.hasOwnProperty(actionName))
                 continue;
@@ -123,29 +156,293 @@ export type IdValue = ${source.idType == "AutoIncInt" || source.idType == "AutoI
             actions[actionName] = {
                 clientCache: (actionName === "findById" || actionName === "findMany") && isAllowCache(entity.actions[actionName], true) ? true : undefined
             };
+
+            switch (actionName) {
+                case "findMany": {
+                    iApiClassBody += ` & MushroomListResource<${typescriptClassName}>`;
+                    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.substr("_raw_http_method_".length)}Async: (rawRequest: MushroomRequest) => Promise<MushroomResponse<any>>,
+`;
+                        break;
+                    }
+                    else {
+                        console.warn(`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) {
-            if (!entity.views.hasOwnProperty(viewName))
+            if (!entity.views.hasOwnProperty(viewName)) continue;
+
+            const viewRoles = entity.views[viewName];
+            if (!Array.isArray(viewRoles) || !viewRoles.length) continue;
+
+            views[viewName] = { clientCache: true };
+
+            const viewParameterTypes = viewRoles.map(view => {
+                const type = `${typescriptClassName}$ViewsResource_${viewName}View_${view.grant === "*" ? "" : toTypeScriptClassName(view.grant)}Parameters`;
+                code += `export interface ${type} ${generateTypescriptClassFromViewParameters(view.parameters)};
+`;
+                return `MushroomViewFunction<any, ${type}>`;
+            });
+            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))});
+
+${extensionsCodeLines.join('\n')}
+
+export interface IApi extends IMushroom {
+${iApiClassBody}};
+
+export type Api = ${extensionsTypes.join('')}IApi;
+
+export default mushroom as Api;`;
+
+    return code;
+}
+
+function genDtsString(aliasProject, source) {
+    if (!aliasProject) {
+        return "";
+    }
+
+    const entities = common.getEntities(source, aliasProject.allowRoles);
+
+    let extensionsImportLines = [];
+    let extensionsExportLines = [];
+    let 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, MushroomResourceBase, MushroomListResource, MushroomFindByIdResource, MushroomCreateResource, MushroomBatchCreateResource, MushroomUpdateResource, MushroomBatchUpdateResource, MushroomPartialUpdateResource, MushroomDeleteResource, MushroomBatchDeleteResource, MushroomExtensibleResource, MushroomViewFunction, MushroomError } from "mushroomjs";
+export * from "mushroomjs";
+${extensionsImportLines.join("\n")}
+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"};
+
+`;
+    let iApiClassBody = "";
+    for (let entityName in entities) {
+        if (!entities.hasOwnProperty(entityName))
+            continue;
+
+        const entity = entities[entityName];
+        const typescriptClassName = toTypeScriptClassName(entityName);
+        code += `export interface ${typescriptClassName} ${generateTypescriptClass(entity.fields)};
+`;
+
+
+        const actions = {};
+        iApiClassBody += `    ${entityName}: MushroomResourceBase`;
+        let customMethodCode = "";
+        for (const actionName in entity.actions) {
+            if (!entity.actions.hasOwnProperty(actionName))
                 continue;
 
+            actions[actionName] = {
+                clientCache: (actionName === "findById" || actionName === "findMany") && isAllowCache(entity.actions[actionName], true) ? true : undefined
+            };
+
+            switch (actionName) {
+                case "findMany": {
+                    iApiClassBody += ` & MushroomListResource<${typescriptClassName}>`;
+                    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.substr("_raw_http_method_".length)}Async: (rawRequest: MushroomRequest) => Promise<MushroomResponse<any>>,
+`;
+                        break;
+                    }
+                    else {
+                        console.warn(`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) {
+            if (!entity.views.hasOwnProperty(viewName)) continue;
+
+            const viewRoles = entity.views[viewName];
+            if (!Array.isArray(viewRoles) || !viewRoles.length) continue;
+
             views[viewName] = { clientCache: true };
+
+            const viewParameterTypes = viewRoles.map(view => {
+                const type = `${typescriptClassName}$ViewsResource_${viewName}View_${view.grant === "*" ? "" : toTypeScriptClassName(view.grant)}Parameters`;
+                code += `export interface ${type} ${generateTypescriptClassFromViewParameters(view.parameters)};
+`;
+                return `MushroomViewFunction<any, ${type}>`;
+            });
+            viewCode += `
+        ${viewName}Async: ${viewParameterTypes.join(' & ')},`;
+        }
+        
+        if (viewCode) {
+            code += `export interface ${typescriptClassName}$ViewsResource {
+    views: {${viewCode}
+    }
+}
+`;
+            iApiClassBody += ` & ${typescriptClassName}$ViewsResource`;
         }
-        code += `defineAsyncResource<${toTypeScriptClassName(entityName)}>(${JSON.stringify({ name: entityName, actions: actions, views: views })});
 
+        iApiClassBody +=`,
 `;
     }
+
     code += `
-mushroom.$using(${JSON.stringify(common.getRootUrl(source))});`;
+export interface IApi extends IMushroom {
+${iApiClassBody}};
+
+declare type Api = ${extensionsTypes.join('')}IApi;
+declare const _default: Api;
+export default _default;`;
+
+    return code;
+}
+
+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 mr config gen ${projectName} ts-driver OUTPUT_FILE.ts${alias === "default" ? "" : " alias " + alias}' first`);
+    }
+
+    const code = genTypescriptDriverString(aliasProject, source);
 
     common.ensureFolder(aliasProject.output);
 
-    fs.writeFile(aliasProject.output, code, err => {
-        if (err)
-            throw err;
-        console.log(`Generated Typescript driver for ${projectName}@${alias} to ${aliasProject.output}`);
-    });
+    fs.writeFileSync(aliasProject.output, code);
+    console.log(`Generated Typescript driver for ${projectName}@${alias} to ${aliasProject.output}`);
 }
 
-module.exports = genTypescriptDriver;
+module.exports = {
+    genTypescriptDriver,
+    genTypescriptDriverString,
+    genDtsString
+};

package/gen.js

@@ -7,8 +7,9 @@ const masterFile = require("./master-file/master-file");
 
 const genApiDocs = require("./gen/gen-api-docs");
 const genDatabaseDocs = require("./gen/gen-db-docs");
-const genJavascriptDriver = require("./gen/gen-js-driver");
-const genTypescriptDriver = require("./gen/gen-ts-driver");
+const javascriptDriverGenerator = require("./gen/gen-js-driver");
+const genJavascriptDriverTarball = require("./gen/gen-js-driver-tarball");
+const typescriptDriverGenerator = require("./gen/gen-ts-driver");
 const csharp = require("./gen/gen-csharp");
 
 
@@ -87,19 +88,22 @@ async function gen(args) {
             await genApiDocs(args, projectName, project, alias, source);
             break;
         case "db-docs":
-            await genDatabaseDocs(args, projectName, project, alias, source);
+            genDatabaseDocs(args, projectName, project, alias, source);
             break;
         case "js-driver":
-            await genJavascriptDriver(args, projectName, project, alias, source);
+            javascriptDriverGenerator.genJavascriptDriver(args, projectName, project, alias, source);
+            break;
+        case "js-driver-tarball":
+            await genJavascriptDriverTarball(args, projectName, project, alias, source);
             break;
         case "ts-driver":
-            await genTypescriptDriver(args, projectName, project, alias, source);
+            typescriptDriverGenerator.genTypescriptDriver(args, projectName, project, alias, source);
             break;
         case "c#-mongo":
-            await csharp.genCSharpMongoDbClasses(args, projectName, project, alias, source);
+            csharp.genCSharpMongoDbClasses(args, projectName, project, alias, source);
             break;
         case "c#-driver":
-            await csharp.genCSharpDriver(args, projectName, project, alias, source);
+            csharp.genCSharpDriver(args, projectName, project, alias, source);
             break;
         case "":
         case undefined:

package/help.js

@@ -31,7 +31,7 @@ Generate database docs (html format)
     npx mr gen projectName[@aliasName] db-docs [tmp]
 
 Config gen javascript driver
-    npx mr config gen projectName js-driver ./src/api/mushroom.api.js [alias aliasName] [roles Admin,User-Contributor]
+    npx mr config gen projectName js-driver ./src/api/mushroom.api.js [alias aliasName] [roles Admin,User-Contributor] [tarball tarballName]
 
 Generate javascript driver
     npx mr gen projectName[@aliasName] js-driver

package/mr.js

@@ -8,6 +8,10 @@ const help = require("./help.js");
 const package = require("./package.json");
 const checkUpdate = require("./check-update");
 
+const versionGroup = package.version.match(/([^-]+)(-(\w+).*)?/);
+const currentDistTag = versionGroup[3] ? versionGroup[3] : "latest";
+console.log("Mushroom CLI version " +  package.version);
+
 async function run(args) {
     let debugMode = false;
     if (args.indexOf("--debug") !== -1) {
@@ -59,8 +63,8 @@ async function run(args) {
     if (checkUpdateTask !== null)
         try {
             var data = await checkUpdateTask;
-            if (data.version && data.version !== package.version) {
-                console.warn("YOUR mushroom-cli VERSION IS NOT LATEST. PLEASE RUN: npm i mushroom-cli@" + data.version);
+            if (data["dist-tags"] && data["dist-tags"][currentDistTag] && data["dist-tags"][currentDistTag] !== package.version) {
+                console.warn(`YOUR mushroom-cli VERSION IS NOT LATEST (dist-tags: ${currentDistTag}). PLEASE RUN: npm i mushroom-cli@${data["dist-tags"][currentDistTag]}`);
             }
         }
         catch(e) {

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "mushroom-cli",
-  "version": "1.0.15",
+  "version": "1.1.0-alpha.10",
   "description": "Mushroom CLI",
   "main": "mr.js",
   "scripts": {
-    "release": "npm publish --access public"
+    "release": "npm publish --access public --tag alpha"
   },
   "keywords": [
     "Mushroom",
@@ -21,6 +21,7 @@
     "json5": "^2.1.2",
     "node-fetch": "^2.6.0",
     "open": "^7.0.3",
-    "readline-sync": "^1.4.10"
+    "readline-sync": "^1.4.10",
+    "targz": "^1.0.1"
   }
-}
+}