mushroom-cli 1.0.17 → 1.1.0-alpha.1

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

@@ -1,7 +1,8 @@
 const fs = require("fs");
 const path = require('path');
 var targz = require('targz');
-const genJavascriptDriver = require("./gen-js-driver");
+const javascriptDriverGenerator = require("./gen-js-driver");
+const typescriptDriverGenerator = require("./gen-ts-driver");
 
 function compressAsync(src, dest, folderName) {
     return new Promise((resolve, reject) => {
@@ -30,22 +31,23 @@ function compressAsync(src, dest, folderName) {
 }
 
 async function genJavascriptDriverTarball(args, projectName, project, alias, source) {
-    genJavascriptDriver(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 mainFileName = path.basename(aliasProject.output);
+    //const mainFileName = path.basename(aliasProject.output);
+    //const dtsFileName = mainFileName.replace(/\.js$/i, ".d.ts");
 
     const packageContent = `{
+    "version": "1.0.${new Date().getTime()}",
     "name": "${tarballName}",
     "private": true,
-    "main": "${mainFileName}",
+    "main": "${tarballName}.js",
+    "types": "${tarballName}.d.ts",
     "dependencies": {
-        "mushroomjs": "^1.0.4"
+        "mushroomjs": "^1.1.0-alpha.5"${Array.isArray(aliasProject.features) && aliasProject.features.includes("auth") ? ',\n        "mushroomjs-auth": "^1.1.0-alpha.4"' : ""}${Array.isArray(aliasProject.features) && aliasProject.features.includes("file") ? ',\n        "mushroomjs-file": "^1.1.0-alpha.1"' : ""}
     }
 }`;
 
@@ -65,16 +67,21 @@ async function genJavascriptDriverTarball(args, projectName, project, alias, sou
 
     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 tarball file  " + tarballFileName);
-
-    fs.copyFileSync(aliasProject.output, path.join(dirPath, mainFileName));
+    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 ${aliasProject.output}`);
+    console.log("Generated tarball file");
     fs.rmdirSync(dirPath, { recursive: true });
     console.log("Cleaned up tarball folder");
 }

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,11 +23,9 @@ 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);
@@ -70,10 +69,31 @@ mushroom.$using(rootApiUrl);
 
 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.writeFileSync(aliasProject.output, code);
-    console.log(`Generated Javascript driver for ${projectName}@${alias} to ${aliasProject.output}`);
+    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,42 @@ 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 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";
+${Array.isArray(aliasProject.features) && aliasProject.features.includes("auth") ? 'import { IMushroomAuth, useAuth, AuthLocalStorage } from "mushroomjs-auth";' : ""}
+${Array.isArray(aliasProject.features) && aliasProject.features.includes("file") ? 'import { IMushroomFile, useFile } from "mushroomjs-file";' : ""}
 
 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 += `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,23 +133,264 @@ 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 += `interface ${typescriptClassName}$CustomMethodResource {
+${customMethodCode}}
+`;
+            iApiClassBody += ` & ${typescriptClassName}$CustomMethodResource`;
         }
 
         const views = {};
+        let viewCode = "";
         for (const viewName in entity.views) {
-            if (!entity.views.hasOwnProperty(viewName))
-                continue;
+            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 += `interface ${type} ${generateTypescriptClassFromViewParameters(view.parameters)};
+`;
+                return `MushroomViewFunction<any, ${type}>`;
+            });
+            viewCode += `
+        ${viewName}Async: ${viewParameterTypes.join(' & ')},`;
         }
-        code += `defineAsyncResource<${toTypeScriptClassName(entityName)}>(${JSON.stringify({ name: entityName, actions: actions, views: views })});
+        
+        if (viewCode) {
+            code += `interface ${typescriptClassName}$ViewsResource {
+    views: {${viewCode}
+    }
+}
+`;
+            iApiClassBody += ` & ${typescriptClassName}$ViewsResource`;
+        }
+
+        iApiClassBody +=`,
+`;
+
+        code += `defineAsyncResource<${typescriptClassName}>(${JSON.stringify({ name: entityName, actions: actions, views: views })});
 
 `;
     }
+
     code += `
+${Array.isArray(aliasProject.features) && aliasProject.features.includes("auth") ? "useAuth(AuthLocalStorage);" : ""}
+${Array.isArray(aliasProject.features) && aliasProject.features.includes("auth") ? "useFile();" : ""}
 mushroom.$using(${JSON.stringify(common.getRootUrl(source))});
 
-export default mushroom;`;
+interface IApi extends IMushroom {
+${iApiClassBody}};
+
+type Api = ${Array.isArray(aliasProject.features) && aliasProject.features.includes("auth") ? "IMushroomAuth & " : ""}${Array.isArray(aliasProject.features) && aliasProject.features.includes("file") ? "IMushroomFile & " : ""}IApi;
+
+export default mushroom as Api;`;
+
+    return code;
+}
+
+function genDtsString(aliasProject, source) {
+    if (!aliasProject) {
+        return "";
+    }
+
+    const entities = common.getEntities(source, aliasProject.allowRoles);
+
+    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";
+${Array.isArray(aliasProject.features) && aliasProject.features.includes("auth") ? 'import { IMushroomAuth } from "mushroomjs-auth";' : ""}
+${Array.isArray(aliasProject.features) && aliasProject.features.includes("file") ? 'import { IMushroomFile } from "mushroomjs-file";' : ""}
+
+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 += `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 += `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 += `interface ${type} ${generateTypescriptClassFromViewParameters(view.parameters)};
+`;
+                return `MushroomViewFunction<any, ${type}>`;
+            });
+            viewCode += `
+        ${viewName}Async: ${viewParameterTypes.join(' & ')},`;
+        }
+        
+        if (viewCode) {
+            code += `interface ${typescriptClassName}$ViewsResource {
+    views: {${viewCode}
+    }
+}
+`;
+            iApiClassBody += ` & ${typescriptClassName}$ViewsResource`;
+        }
+
+        iApiClassBody +=`,
+`;
+    }
+
+    code += `
+interface IApi extends IMushroom {
+${iApiClassBody}};
+
+declare type Api = ${Array.isArray(aliasProject.features) && aliasProject.features.includes("auth") ? "IMushroomAuth & " : ""}${Array.isArray(aliasProject.features) && aliasProject.features.includes("file") ? "IMushroomFile & " : ""}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);
 
@@ -147,4 +398,8 @@ export default mushroom;`;
     console.log(`Generated Typescript driver for ${projectName}@${alias} to ${aliasProject.output}`);
 }
 
-module.exports = genTypescriptDriver;
+module.exports = {
+    genTypescriptDriver,
+    genTypescriptDriverString,
+    genDtsString
+};

package/gen.js

@@ -7,9 +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 javascriptDriverGenerator = require("./gen/gen-js-driver");
 const genJavascriptDriverTarball = require("./gen/gen-js-driver-tarball");
-const genTypescriptDriver = require("./gen/gen-ts-driver");
+const typescriptDriverGenerator = require("./gen/gen-ts-driver");
 const csharp = require("./gen/gen-csharp");
 
 
@@ -91,13 +91,13 @@ async function gen(args) {
             genDatabaseDocs(args, projectName, project, alias, source);
             break;
         case "js-driver":
-            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":
-            genTypescriptDriver(args, projectName, project, alias, source);
+            typescriptDriverGenerator.genTypescriptDriver(args, projectName, project, alias, source);
             break;
         case "c#-mongo":
             csharp.genCSharpMongoDbClasses(args, projectName, project, alias, source);

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "mushroom-cli",
-  "version": "1.0.17",
+  "version": "1.1.0-alpha.1",
   "description": "Mushroom CLI",
   "main": "mr.js",
   "scripts": {
-    "release": "npm publish --access public"
+    "release": "npm publish --access public --tag alpha"
   },
   "keywords": [
     "Mushroom",