mushroom-cli 1.2.8 → 2.0.0-alpha.0

package/README.md

@@ -1,5 +1,9 @@
 # Mushroom CLI
 
+> In the examples below, `[...]` marks an optional argument and `|` separates alternatives. They are notation, not
+> characters to type. Quote any argument containing spaces, for example
+> `npx mushroom-cli config add "./my api/project.json"`.
+
 ## Init
 
 Init a mushroom json file
@@ -8,10 +12,10 @@ Init a mushroom json file
 npx mushroom-cli init json ./api/SampleProject.json [silent]
 ```
 
-Init a DotNet Core project which pre-install Mushroom Server
+Init a DotNet project
 
 ```bash
-npx mushroom-cli init netcore [projectName]
+npx mushroom-cli init netcore [projectName] [--version latest|alpha|0.2|0.3]
 ```
 
 ## Configure
@@ -31,19 +35,19 @@ npx mushroom-cli config gen projectName docs ./wwwroot/docs.html [alias aliasNam
 Config gen database docs
 
 ```bash
-npx mushroom-cli config gen projectName "db-docs" ./wwwroot/db-docs.html [alias aliasName] [features file,auth,mail]
+npx mushroom-cli config gen projectName db-docs ./wwwroot/db-docs.html [alias aliasName] [features file,auth,mail]
 ```
 
 Config gen javascript driver
 
 ```bash
-npx mushroom-cli config gen projectName "js-driver" ./src/api/mushroom.api.js [alias aliasName] [roles Admin,User-Contributor] [tarball tarballName]
+npx mushroom-cli config gen projectName js-driver ./src/api/mushroom.api.js [alias aliasName] [roles Admin,User-Contributor]
 ```
 
 Config gen typescript driver
 
 ```bash
-npx mushroom-cli config gen projectName "ts-driver" ./src/api/mushroom.api.ts [alias aliasName] [roles Admin,User-Contributor]
+npx mushroom-cli 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
@@ -58,36 +62,30 @@ Config gen entities for CSharp project which calls Mushroom API
 npx mushroom-cli config gen projectName "c#-driver" ./API/Generated.cs [roles Admin,User-Contributor] [alias aliasName] [access-modifier public] [features file,auth,mail]
 ```
 
-## Genarate
+## Generate
 
 Generate docs api (html format)
 
 ```bash
-npx mushroom-cli gen projectName[@aliasName] docs [v1] [tmp]
+npx mushroom-cli gen projectName[@aliasName] docs [tmp]
 ```
 
 Generate database docs (html format)
 
 ```bash
-npx mushroom-cli gen projectName[@aliasName] "db-docs" [tmp]
-```
-
-Generate npm package (tarball file)
-
-```bash
-npx mushroom-cli gen projectName[@aliasName] "js-driver-tarball"
+npx mushroom-cli gen projectName[@aliasName] db-docs [tmp]
 ```
 
 Generate javascript driver
 
 ```bash
-npx mushroom-cli gen projectName[@aliasName] "js-driver"
+npx mushroom-cli gen projectName[@aliasName] js-driver
 ```
 
 Generate typescript driver
 
 ```bash
-npx mushroom-cli gen projectName[@aliasName] "ts-driver"
+npx mushroom-cli gen projectName[@aliasName] ts-driver
 ```
 
 Generate entities for Mushroom project in CSharp and using MongoDb
@@ -113,13 +111,13 @@ npx mushroom-cli merge output-path.json
 Update ts code (configuration was stored in mushroom-config.json file)
 
 ```bash
-npx mushroom-cli update "ts-code"
+npx mushroom-cli update ts-code
 ```
 
 Update ts code (simple call)
 
 ```bash
-npx mushroom-cli update "ts-code" file-path.ts remote-ts-code-url
+npx mushroom-cli update ts-code file-path.ts remote-ts-code-url
 ```
 
 ## Other
@@ -132,6 +130,42 @@ npx mushroom-cli parameters --no-check-update
 
 ## Version
 
+### 2.0.0-alpha.0
+
+Breaking changes:
+
+- gen docs: remove the docs engine v1. The `v1` parameter is now ignored with a warning and the v1.2 engine is always
+  used
+- gen js-driver: remove the `js-driver-tarball` command, the `tarball tarballName` option of `config gen js-driver`
+  and the `jsDriver.alias.*.tarballName` field in mushroom-config.json
+- gen c#-mongo: generated code now requires Mushroom Server 0.3 or higher
+- require Node.js `>=14.13.1`
+
+New features:
+
+- init netcore: `npx mushroom-cli init netcore [--version 0.2|0.3|latest|alpha]` to select the template branch
+- init netcore: the `replace` step accepts wildcards in the file name, for example `./api/*.json` or
+  `./api/dulich-*.json`, and resolves them recursively including sub-folders
+- gen c#-mongo: support `routes` in the master file (`path`, `pathMode`, `caseInsensitive`, `httpMethod`, `grant`,
+  `deny`, `logRetentionMode`, `delegator`, `codeHint`)
+- gen c#-mongo: support `extensions` in the master file (`startup`, `config`, `ensureIndex`, `routes`) and generate
+  the matching extension event handlers
+- gen c#-mongo: new registration signatures `RegisterJob`, `RegisterBeforeEvent`, `RegisterAfterEvent`,
+  `RegisterCustomLoginAsyncHandler`, `RegisterGetAuthLogInfoAsyncHandler`, `RegisterLoginSuccessHandler`,
+  `RegisterSendCodeItemHandler`, `RegisterCustomVnTextBuilderMethod`
+
+Improvement/Changes:
+
+- gen docs: inline `bootstrap.min.css`, `bootstrap-theme.min.css`, `bootstrap.min.js` and `jquery.min.js` into the
+  html. The generated docs is now a single self-contained file and no static file is copied next to it
+- gen docs: build the whole document in memory and write it once, about 4 times faster
+- gen c#-mongo, gen c#-driver: escape descriptions for XML docs comments
+- init netcore: clone the template with `--depth 1`
+- replace `minify` with `html-minifier-terser` and use `open` 8: installing the CLI drops from 84 packages (75 MB) to
+  36 packages (20 MB) and works on Node.js 14 again
+- the `only-allow npm` check moved from `preinstall` to `prepare` so it no longer runs when the CLI is installed as a
+  dependency
+
 ### 1.2.8
 
 Improvement

package/dist/common.js

@@ -1,7 +1,6 @@
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import readlineSync from 'readline-sync';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export function getPackageVersion() {
@@ -131,148 +130,6 @@ export function filterRoles(roleList, allowRoleList) {
     });
     return roles;
 }
-export function processTemplate(basePath, templatePath) {
-    const templateJsonContent = fs.readFileSync(path.join(basePath, templatePath)).toString();
-    const template = JSON.parse(templateJsonContent);
-    if (template && typeof template !== 'object') {
-        throw new TypeError(`Invalid template file ${templatePath}`);
-    }
-    const commands = template.steps;
-    if (!Array.isArray(commands)) {
-        throw new TypeError(`Invalid template file ${templatePath}`);
-    }
-    const variables = {};
-    commands.forEach((command) => processCommand(command, basePath, variables));
-    return variables;
-}
-function processCommand(command, basePath, variables) {
-    const commandName = command.command;
-    switch (commandName) {
-        case 'input':
-            processInputCommand(command, variables);
-            return;
-        case 'set':
-            processSetCommand(command, variables);
-            return;
-        case 'rename':
-            processRenameCommand(command, basePath, variables);
-            return;
-        case 'delete':
-            processDeleteCommand(command, basePath, variables);
-            return;
-        case 'replace':
-            processReplaceCommand(command, basePath, variables);
-            return;
-        default:
-            throw new Error(`Unknown command: ${commandName}`);
-    }
-}
-function processInputCommand(command, variables) {
-    const value = readlineSync.question(command.message ?? '');
-    if (command.validation) {
-        if (command.validation.required) {
-            if (value === '')
-                throw new TypeError(`${command.variable} is required`);
-        }
-        if (command.validation.pattern) {
-            if (!new RegExp(command.validation.pattern).test(value))
-                throw new Error(`${value} is not valid`);
-        }
-    }
-    variables[command.variable] = value;
-}
-function processSetCommand(command, variables) {
-    switch (command['function']) {
-        case 'New-GUID':
-            processSetNewGuidCommand(command.variable, variables);
-            break;
-        case 'New-RandomNumber':
-            processSetNewRandomNumberCommand(command.variable, variables, command.min, command.max);
-            break;
-        case 'New-RandomString':
-            processSetNewRandomStringCommand(command.variable, variables, command.length, command.characterPool);
-            break;
-        case 'ToLowerCase':
-            toLowerCommand(command.variable, variables, command.input);
-            break;
-        case 'ToUpperCase':
-            toUpperCaseCommand(command.variable, variables, command.input);
-            break;
-        case 'Trim':
-            trimCommand(command.variable, variables, command.input);
-            break;
-        case 'Replace':
-            replaceCommand(command.variable, variables, command.input, command.replacement, command.pattern, command.mode);
-            break;
-        default:
-            throw new Error(`Unknown set-command: ${command['function']}`);
-    }
-}
-function processSetNewGuidCommand(variable, variables) {
-    variables[variable] = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'
-        .replace(/[xy]/g, (c) => {
-        const r = (Math.random() * 16) | 0;
-        const v = c == 'x' ? r : (r & 0x3) | 0x8;
-        return v.toString(16);
-    })
-        .toUpperCase();
-}
-function processSetNewRandomNumberCommand(variable, variables, min = 0, max = (1 << 30) * 4) {
-    variables[variable] = Math.floor(min + Math.random() * (max - min)).toString();
-}
-function processSetNewRandomStringCommand(variable, variables, length, characterPool = '1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM') {
-    let result = '';
-    for (let i = 0; i < length; i++) {
-        result += characterPool.charAt(Math.floor(Math.random() * characterPool.length));
-    }
-    variables[variable] = result;
-}
-function toLowerCommand(variable, variables, input) {
-    variables[variable] = variables[input].toLowerCase();
-}
-function toUpperCaseCommand(variable, variables, input) {
-    variables[variable] = variables[input].toUpperCase();
-}
-function trimCommand(variable, variables, input) {
-    variables[variable] = variables[input].trim();
-}
-function replaceCommand(variable, variables, input, replacement, pattern, mode) {
-    const regex = new RegExp(pattern, mode);
-    variables[variable] = variables[input].replace(regex, replacement);
-}
-function processRenameCommand(command, basePath, variables) {
-    const input = replaceVariables(command.input, variables);
-    const output = replaceVariables(command.output, variables);
-    fs.renameSync(path.join(basePath, input), path.join(basePath, output));
-}
-function processDeleteCommand(command, basePath, variables) {
-    const input = replaceVariables(command.input, variables);
-    const deletedPath = path.join(basePath, input);
-    if (fs.lstatSync(deletedPath).isDirectory()) {
-        fs.rmSync(deletedPath, { recursive: true, force: true });
-    }
-    else {
-        fs.rmSync(deletedPath, { force: true });
-    }
-}
-function processReplaceCommand(command, basePath, variables) {
-    const files = command.input;
-    const pattern = new RegExp(command.pattern ?? '', 'g');
-    const replacement = replaceVariables(command.replacement ?? '', variables);
-    files.forEach((file) => {
-        const filePath = path.join(basePath, replaceVariables(file, variables));
-        if (!fs.existsSync(filePath)) {
-            console.warn(`File ${file} does not exist, skipping...`);
-            return;
-        }
-        let content = fs.readFileSync(filePath).toString();
-        content = content.replace(pattern, () => replacement);
-        fs.writeFileSync(filePath, content);
-    });
-}
-function replaceVariables(str, variables) {
-    return str.replace(/\$\{(\w+)\}/g, (_, varName) => variables[varName] ?? '');
-}
 export function logInfo(message, ...parameters) {
     console.log(message, ...parameters);
 }

package/dist/config.js

@@ -170,13 +170,6 @@ function configGenJavascriptDriver(args, mushroomConfig, projectName) {
                     alias = strAlias;
                 break;
             }
-            case 'tarball': {
-                index++;
-                const strTarball = args[index];
-                if (strTarball)
-                    parameters.tarballName = strTarball;
-                break;
-            }
         }
         index++;
     }

package/dist/docs/docs.html

@@ -1310,8 +1310,8 @@
           // fieldName: value
       };
       try {
-          const newId = await mushroom.<span data-mt-attr='{"text": "$entityName"}'></span>.createAsync(<span data-mt-attr='{"text": "$entityName"}'></span>_object);
-          console.log("Thêm mới thành công, new id: %o", newId);
+          const response = await mushroom.<span data-mt-attr='{"text": "$entityName"}'></span>.createAsync(<span data-mt-attr='{"text": "$entityName"}'></span>_object);
+          console.log("Thêm mới thành công, new id: %o", response.result);
       } catch (error) {
           console.error("Có lỗi: %o", error);
       }</pre>

package/dist/gen/csharp/extEvents.js

@@ -0,0 +1,195 @@
+const extEvents = {
+    auth: {
+        'Events.Login.Before': {
+            type: 'Before',
+        },
+        'Events.Login.Validate.Before': {
+            type: 'Before',
+        },
+        'Events.Login.Validate.After': {
+            type: 'After',
+        },
+        'Events.Login.CheckLocking.Before': {
+            type: 'Before',
+        },
+        'Events.Login.CheckLocking.After': {
+            type: 'After',
+            data: 'Mushroom.Extensions.DefaultAuth.UserLock',
+        },
+        CustomLoginAsyncFunc: {
+            type: 'Func',
+            registerFunc: 'RegisterCustomLoginAsyncHandler',
+        },
+        'Events.Login.LogAuth.Before': {
+            type: 'Before',
+        },
+        GetAuthLogInfoAsyncFunc: {
+            type: 'Func',
+            registerFunc: 'RegisterGetAuthLogInfoAsyncHandler',
+        },
+        'Events.Login.LogAuth.After': {
+            type: 'After',
+            data: 'Mushroom.Extensions.DefaultAuth.UserAuthLogResult',
+        },
+        'Events.Login.LoginFail': {
+            type: 'After',
+        },
+        'Events.Login.LoginSuccess': {
+            type: 'Event',
+            registerFunc: 'RegisterLoginSuccessHandler',
+        },
+        'Events.Login.After': {
+            type: 'After',
+            data: 'string',
+        },
+        'Events.Logout.Before': {
+            type: 'Before',
+        },
+        'Events.Logout.After': {
+            type: 'After',
+            data: 'bool',
+        },
+        'Events.Status.Before': {
+            type: 'Before',
+        },
+        'Events.Status.After': {
+            type: 'After',
+            data: 'bool',
+        },
+        'Events.Me.Before': {
+            type: 'Before',
+        },
+        'Events.Me.After': {
+            type: 'After',
+            data: 'Mushroom.Extensions.DefaultAuth.User',
+        },
+        'Events.Register.Before': {
+            type: 'Before',
+        },
+        SendCodeItemFunc: {
+            type: 'Func',
+            registerFunc: 'RegisterSendCodeItemHandler',
+        },
+        'Events.Register.After': {
+            type: 'After',
+            data: 'Mushroom.Extensions.DefaultAuth.User',
+        },
+        'Events.Activate.Before': {
+            type: 'Before',
+        },
+        'Events.Activate.After': {
+            type: 'After',
+            data: 'Mushroom.Extensions.DefaultAuth.User',
+        },
+        'Events.RecoverPassword.Before': {
+            type: 'Before',
+        },
+        'Events.RecoverPassword.After': {
+            type: 'After',
+            data: 'Mushroom.Extensions.DefaultAuth.User',
+        },
+        'Events.ResetPassword.Before': {
+            type: 'Before',
+        },
+        'Events.ResetPassword.After': {
+            type: 'After',
+            data: 'Mushroom.Extensions.DefaultAuth.User',
+        },
+    },
+    file: {
+        'Events.Upload.Before': {
+            type: 'Before',
+        },
+        'Events.Upload.After': {
+            type: 'After',
+        },
+        'Events.Thumb.Before': {
+            type: 'Before',
+        },
+        'Events.Thumb.After': {
+            type: 'After',
+        },
+        'Events.Download.Before': {
+            type: 'Before',
+        },
+        'Events.Download.After': {
+            type: 'After',
+        },
+        'Events.Zip.Before': {
+            type: 'Before',
+        },
+        'Events.Zip.After': {
+            type: 'After',
+        },
+        LimitFileUploadSizeFunc: {
+            type: 'Func',
+            data: 'System.Threading.Tasks.Task<long?>',
+        },
+    },
+    mail: {
+        AuthorizationFunc: {
+            type: 'Func',
+            data: 'System.Threading.Tasks.Task<bool>, Mushroom.Extensions.Mailing.MailingAuthorizationArgument',
+        },
+    },
+};
+export const getExtensionEventsCode = (source, newLine) => {
+    const eventCodes = [];
+    const addEventCodes = (key, code, source) => {
+        const eventCode = eventCodes.find((ec) => ec.key === key);
+        if (eventCode) {
+            eventCode.source.push(source);
+            return;
+        }
+        eventCodes.push({
+            key,
+            code,
+            source: [source],
+        });
+    };
+    Object.keys(extEvents).forEach((ext) => {
+        const extension = source.extensions?.[ext];
+        if (!extension?.config)
+            return;
+        const config = extension.config;
+        Object.keys(extEvents[ext]).forEach((configName) => {
+            const def = extEvents[ext][configName];
+            const configValue = config[configName];
+            if (!configValue || typeof configValue !== 'string' || !configValue.startsWith('lib:'))
+                return;
+            if (def.type == 'Func') {
+                const defaultFunc = `RegisterCustomMethod<${def.data || 'System.Threading.Tasks.Task'}>`;
+                addEventCodes(ext + '.' + configName, `${def.registerFunc || defaultFunc}(${configValue.substring(4)});`, `extension: ${ext} - config: ${configName}`);
+                return;
+            }
+            if (def.type == 'Event') {
+                configValue.split(',').forEach((lib) => {
+                    if (!lib || !lib.startsWith('lib:'))
+                        return;
+                    addEventCodes(ext + '.' + configName, `${def.registerFunc || 'RegisterEvent'}(${lib.substring(4)});`, `extension: ${ext} - config: ${configName}`);
+                });
+                return;
+            }
+            if (def.type == 'Before') {
+                configValue.split(',').forEach((lib) => {
+                    if (!lib || !lib.startsWith('lib:'))
+                        return;
+                    addEventCodes(ext + '.' + configName, `${def.registerFunc || 'RegisterBeforeEvent'}(${lib.substring(4)});`, `extension: ${ext} - config: ${configName}`);
+                });
+                return;
+            }
+            if (def.type == 'After') {
+                configValue.split(',').forEach((lib) => {
+                    if (!lib || !lib.startsWith('lib:'))
+                        return;
+                    addEventCodes(ext + '.' + configName, `${def.registerFunc || (def.data ? `RegisterAfterEvent<${def.data}>` : 'RegisterAfterEvent')}(${lib.substring(4)});`, `extension: ${ext} - config: ${configName}`);
+                });
+                return;
+            }
+            return '';
+        });
+    });
+    return eventCodes
+        .map((ec) => `${ec.source.map((s) => '            // ' + s).join(newLine)}${newLine}            ${ec.code}`)
+        .join(newLine);
+};

package/dist/gen/gen-api-docs.js

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import open from 'open';
-import { minify } from 'minify';
+import { minify } from 'html-minifier-terser';
 import { fileURLToPath } from 'url';
 import path from 'path';
 import * as common from '../common.js';
@@ -227,42 +227,58 @@ function filterEntityFields(entity) {
 async function writeDocs(filePath, strTemplate, strData) {
     const placeholder = '<script id="INJECT-JAVASCRIPT-HERE"></script>';
     const idx = strTemplate.indexOf(placeholder);
-    fs.writeFileSync(filePath, strTemplate.substring(0, idx));
-    fs.appendFileSync(filePath, '<script>window.docs = ');
-    fs.appendFileSync(filePath, strData);
-    fs.appendFileSync(filePath, ';\n');
-    fs.appendFileSync(filePath, fs.readFileSync(path.join(__dirname, '../docs/docs.v2.js')));
-    fs.appendFileSync(filePath, '</script>');
-    fs.appendFileSync(filePath, strTemplate.substring(idx + placeholder.length));
-    fs.writeFileSync(filePath, await minify(filePath, {
-        html: {
-            removeComments: true,
-            collapseWhitespace: true,
-            collapseBooleanAttributes: true,
-            removeAttributeQuotes: true,
-            removeRedundantAttributes: true,
-            useShortDoctype: true,
-            removeEmptyAttributes: true,
-            removeEmptyElements: false,
-            removeOptionalTags: true,
-            removeScriptTypeAttributes: false,
-            removeStyleLinkTypeAttributes: true,
-            minifyJS: true,
-            minifyCSS: true,
-            html5: true,
-        },
-    }));
-    copyStaticFiles(path.dirname(filePath), [
-        'bootstrap-theme.min.css',
-        'bootstrap.min.css',
-        'bootstrap.min.js',
-        'jquery.min.js',
-    ]);
+    if (idx === -1) {
+        throw new Error(`Docs template does not contain the placeholder ${placeholder}`);
+    }
+    const docsScript = fs.readFileSync(path.join(__dirname, '../docs/docs.v2.js')).toString();
+    let html = strTemplate.substring(0, idx) +
+        '<script>window.docs = ' +
+        strData +
+        ';\n' +
+        docsScript +
+        '</script>' +
+        strTemplate.substring(idx + placeholder.length);
+    html = await minify(html, {
+        removeComments: true,
+        collapseWhitespace: true,
+        collapseBooleanAttributes: true,
+        removeAttributeQuotes: true,
+        removeRedundantAttributes: true,
+        useShortDoctype: true,
+        removeEmptyAttributes: true,
+        removeEmptyElements: false,
+        removeOptionalTags: true,
+        removeScriptTypeAttributes: false,
+        removeStyleLinkTypeAttributes: true,
+        minifyJS: true,
+        minifyCSS: true,
+        html5: true,
+    });
+    html = injectStaticFiles(html, ['bootstrap-theme.min.css', 'bootstrap.min.css', 'bootstrap.min.js', 'jquery.min.js']);
+    fs.writeFileSync(filePath, html);
 }
-const copyStaticFiles = (folderPath, files) => {
+const injectStaticFiles = (content, files) => {
+    let html = content;
     files.forEach((file) => {
-        fs.copyFileSync(path.join(__dirname, '../docs/', file), path.join(folderPath, file));
+        const sourcePath = path.join(__dirname, '../docs/', file);
+        if (!fs.existsSync(sourcePath)) {
+            common.logWarning(`Static file ${file} does not exist, skipping...`);
+            return;
+        }
+        const escapedFile = file.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const isCss = path.extname(file).toLowerCase() === '.css';
+        const tagPattern = isCss
+            ? new RegExp(`<link[^>]*href=["']?${escapedFile}["']?[^>]*>`, 'gi')
+            : new RegExp(`<script[^>]*src=["']?${escapedFile}["']?[^>]*>\\s*</script>`, 'gi');
+        if (!tagPattern.test(html)) {
+            return;
+        }
+        tagPattern.lastIndex = 0;
+        const assetContent = fs.readFileSync(sourcePath).toString();
+        const inlined = isCss ? `<style>${assetContent}</style>` : `<script>${assetContent}</script>`;
+        html = html.replace(tagPattern, () => inlined);
     });
+    return html;
 };
 export default async function genDocs(args, projectName, project, alias, source) {
     const aliasProject = ((project.docs || {}).alias || {})[alias];
@@ -300,6 +316,7 @@ export default async function genDocs(args, projectName, project, alias, source)
         environmentVariables: source.environmentVariables,
         entities: entities,
     });
+    common.ensureFolder(aliasProject.output);
     const html = fs.readFileSync(__dirname + '/../docs/docs.v2.html').toString();
     if (args[3] === 'tmp') {
         const htmlFilePath = aliasProject.output + '_tmp.html';
@@ -320,7 +337,6 @@ export default async function genDocs(args, projectName, project, alias, source)
         }
         return;
     }
-    common.ensureFolder(aliasProject.output);
     common.logInfo('Writing to', aliasProject.output);
     await writeDocs(aliasProject.output, html, data);
     common.logInfo(`Generated API docs for ${projectName}@${alias} to ${aliasProject.output}`);