mushroom-cli 1.2.7 → 2.0.0-alpha.0

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

@@ -0,0 +1,52 @@
+import * as common from '../common.js';
+export function listApi(source) {
+    const entities = common.getEntities(source, ['*'], true);
+    const endpoints = new Set();
+    for (const entityName in entities) {
+        const actions = entities[entityName].actions || {};
+        for (const actionName in actions) {
+            const action = actions[actionName];
+            if (!Array.isArray(action) || !action.length || action.every((a) => !a.enabled))
+                continue;
+            let method;
+            let id = '';
+            if (actionName == 'findById') {
+                method = 'GET';
+                id = '/{{id}}';
+            }
+            if (actionName == 'findMany')
+                method = 'GET';
+            else if (actionName == 'createOne' || actionName == 'createMany')
+                method = 'POST';
+            else if (actionName?.startsWith('_raw_http_method_')) {
+                method = 'POST';
+                id = '/' + actionName.substring('_raw_http_method_'.length);
+            }
+            else if (actionName == 'updateOne') {
+                method = 'PUT';
+                id = '/{{id}}';
+            }
+            else if (actionName == 'updateMany')
+                method = 'PUT';
+            else if (actionName == 'updatePartially') {
+                method = 'PATCH';
+                id = '/{{id}}';
+            }
+            else if (actionName == 'deleteOne') {
+                method = 'DELETE';
+                id = '/{{id}}';
+            }
+            else if (actionName == 'deleteMany')
+                method = 'DELETE';
+            endpoints.add(`${method} ${source.rootUrl}${entityName}s${id}`);
+        }
+        const views = entities[entityName].views || {};
+        for (const viewName in views) {
+            const view = views[viewName];
+            if (!Array.isArray(view) || !view.length || view.every((v) => !v.enabled))
+                continue;
+            endpoints.add(`GET ${source.rootUrl}${entityName}s/views/${viewName}`);
+        }
+    }
+    endpoints.forEach((e) => console.log(e));
+}

package/dist/gen.js

@@ -5,11 +5,10 @@ import help from './help.js';
 import * as common from './common.js';
 import * as masterFile from './master-file/master-file.js';
 import genApiDocs from './gen/gen-api-docs.js';
-import genApiDocsV1 from './gen/gen-api-docs-v1.js';
 import genDatabaseDocs from './gen/gen-db-docs.js';
 import * as javascriptDriverGenerator from './gen/gen-js-driver.js';
-import genJavascriptDriverTarball from './gen/gen-js-driver-tarball.js';
 import * as typescriptDriverGenerator from './gen/gen-ts-driver.js';
+import * as listApi from './gen/gen-list-api.js';
 import * as csharp from './gen/gen-csharp.js';
 export default async function gen(args) {
     let projectName = args[1];
@@ -73,10 +72,10 @@ export default async function gen(args) {
     const type = args[2];
     switch (type) {
         case 'docs':
-            if (args.includes('v1'))
-                await genApiDocsV1(args.filter((p) => p != 'v1'), projectName, project, alias, source);
-            else
-                await genApiDocs(args, projectName, project, alias, source);
+            if (args.includes('v1')) {
+                common.logWarning('Parameter v1 is ignored');
+            }
+            await genApiDocs(args, projectName, project, alias, source);
             break;
         case 'db-docs':
             genDatabaseDocs(args, projectName, project, alias, source);
@@ -84,9 +83,6 @@ export default async function gen(args) {
         case 'js-driver':
             javascriptDriverGenerator.genJavascriptDriver(args, projectName, project, alias, source);
             break;
-        case 'js-driver-tarball':
-            await genJavascriptDriverTarball(args, projectName, project, alias, source);
-            break;
         case 'ts-driver':
             typescriptDriverGenerator.genTypescriptDriver(args, projectName, project, alias, source);
             break;
@@ -96,7 +92,9 @@ export default async function gen(args) {
         case 'c#-driver':
             csharp.genCSharpDriver(args, projectName, project, alias, source);
             break;
-        case '':
+        case 'list-api':
+            listApi.listApi(source);
+            break;
         case undefined:
         case 'help':
         case 'man':

package/dist/help.js

@@ -13,25 +13,25 @@ export default function help(key, wrong) {
     npx mushroom-cli init json ./api/SampleProject.json [silent]
 
 Init a dotnet core project which pre-install Mushroom Server
-    npx mushroom-cli init netcore
+    npx mushroom-cli init netcore [--version 0.2|0.3|latest|alpha]
 
 Add the mushroom json file into mushroom-config.json
     npx mushroom-cli config add ./api/yourProjectName.json
 
 Config gen docs api
-    npx mushroom-cli config gen projectName docs ./wwwroot/docs.html [alias aliasName] [features file,auth,mail,driver] [roles Admin,User-Contributor]
+    npx mushroom-cli config gen projectName docs ./wwwroot/docs.html [alias aliasName]
 
 Generate docs api (html format)
     npx mushroom-cli gen projectName[@aliasName] docs [tmp]
 
 Config gen database docs
-    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]
 
 Generate database docs (html format)
     npx mushroom-cli gen projectName[@aliasName] db-docs [tmp]
 
 Config gen javascript driver
-    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]
 
 Generate javascript driver
     npx mushroom-cli gen projectName[@aliasName] js-driver
@@ -43,7 +43,7 @@ Generate entities for Mushroom project in CSharp and using MongoDb
     npx mushroom-cli gen projectName[@aliasName] c#-mongo
 
 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]
+    npx mushroom-cli config gen projectName c#-driver ./API/Generated.cs [alias aliasName]
 
 Generate entities for CSharp project which calls Mushroom API
     npx mushroom-cli gen projectName[@aliasName] c#-driver

package/dist/init/init-netcore.js

@@ -1,13 +1,27 @@
 import { spawn } from 'child_process';
 import * as common from '../common.js';
-function fetchFromGit() {
+import * as templateProcessor from './netcore/templateProcessor.js';
+const branches = {
+    '0.2': '0.2',
+    '0.3': 'latest',
+    latest: 'latest',
+    alpha: 'alpha',
+};
+function fetchFromGit(version) {
     return new Promise((resolve, reject) => {
+        const branch = branches[version];
+        if (!branch) {
+            reject(new Error('Unknown version ' + version));
+            return;
+        }
         const git = spawn('git', [
             'clone',
-            'https://tfs.siten.vn:8080/tfs/Siten/CodeBase/_git/Mushroom',
+            'https://tfs.siten.vn:8080/Siten/CodeBase/_git/Mushroom',
             '-b',
-            'full_extensions',
+            branch,
             '--single-branch',
+            '--depth',
+            '1',
         ]);
         git.stdout.on('data', (data) => {
             common.logInfo('GIT:', data?.toString());
@@ -25,6 +39,13 @@ function fetchFromGit() {
     });
 }
 export default async function initNetCore(args) {
-    await fetchFromGit();
-    common.processTemplate('Mushroom', 'mushroom-template.json');
+    let version;
+    for (let i = 2; i < args.length; i++) {
+        if (args[i] === '--version') {
+            version = args[i + 1];
+            i++;
+        }
+    }
+    await fetchFromGit(version ?? 'latest');
+    templateProcessor.process('Mushroom', 'mushroom-template.json');
 }

package/dist/init/netcore/templateProcessor.js

@@ -0,0 +1,182 @@
+import fs from 'fs';
+import path from 'path';
+import readlineSync from 'readline-sync';
+import * as common from '../../common.js';
+export function process(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 resolvedInput = replaceVariables(file, variables);
+        const filePaths = resolveInputPaths(basePath, resolvedInput);
+        if (filePaths.length === 0) {
+            common.logWarning(`File ${file} does not exist, skipping...`);
+            return;
+        }
+        filePaths.forEach((filePath) => {
+            let content = fs.readFileSync(filePath).toString();
+            content = content.replace(pattern, () => replacement);
+            fs.writeFileSync(filePath, content);
+        });
+    });
+}
+function resolveInputPaths(basePath, input) {
+    const fileName = path.basename(input);
+    if (/[*?]/.test(fileName)) {
+        const dir = path.join(basePath, path.dirname(input));
+        if (!fs.existsSync(dir)) {
+            return [];
+        }
+        return findFilesByGlob(dir, globToRegExp(fileName));
+    }
+    const filePath = path.join(basePath, input);
+    return fs.existsSync(filePath) ? [filePath] : [];
+}
+function globToRegExp(glob) {
+    const pattern = glob
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+    return new RegExp(`^${pattern}$`, 'i');
+}
+function findFilesByGlob(dir, fileNamePattern) {
+    const results = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    entries.forEach((entry) => {
+        const entryPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...findFilesByGlob(entryPath, fileNamePattern));
+        }
+        else if (fileNamePattern.test(entry.name)) {
+            results.push(entryPath);
+        }
+    });
+    return results;
+}
+function replaceVariables(str, variables) {
+    return str.replace(/\$\{(\w+)\}/g, (_, varName) => variables[varName] ?? '');
+}

package/package.json

@@ -1,16 +1,14 @@
 {
   "name": "mushroom-cli",
-  "version": "1.2.7",
+  "version": "2.0.0-alpha.0",
   "description": "Mushroom CLI",
-  "main": "dist/mr.js",
   "type": "module",
   "scripts": {
     "build": "tsc && copyfiles -u 2 ./src/docs/* ./dist/docs/",
     "format": "prettier --write --ignore-unknown **/*",
     "lint": "eslint ./src/**/*.ts",
-    "release": "npm run build && npm publish --access public",
-    "preinstall": "npx only-allow npm",
-    "prepare": "husky"
+    "release": "npm run build && npm publish --access public --tag alpha",
+    "prepare": "npx only-allow npm && husky || exit 0"
   },
   "lint-staged": {
     "!(*.ts)": "prettier --write --ignore-unknown",
@@ -33,22 +31,17 @@
   "author": "suco2007",
   "license": "ISC",
   "dependencies": {
-    "jsdom": "^29.1.1",
+    "html-minifier-terser": "^7.2.0",
     "json5": "^2.2.3",
-    "minify": "^15.3.1",
     "node-fetch": "^3.3.2",
-    "open": "^11.0.0",
-    "readline-sync": "^1.4.10",
-    "targz": "^1.0.1"
+    "open": "^8.4.2",
+    "readline-sync": "^1.4.10"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
-    "@types/jsdom": "^27.0.0",
-    "@types/minify": "^9.1.4",
+    "@types/html-minifier-terser": "^7.0.2",
     "@types/node": "^22.15.29",
-    "@types/node-fetch": "^2.6.13",
     "@types/readline-sync": "^1.4.8",
-    "@types/targz": "^1.0.5",
     "copyfiles": "^2.4.1",
     "eslint": "^9.39.2",
     "husky": "^9.1.7",
@@ -59,6 +52,6 @@
     "typescript-eslint": "^8.51.0"
   },
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=14.13.1"
   }
 }