mushroom-cli 1.2.0-alpha.8 → 1.2.0

package/dist/master-file/master-file.js

@@ -0,0 +1,185 @@
+import fs from 'fs';
+import path from 'path';
+import JSON5 from 'json5';
+import * as common from '../common.js';
+function transformValidationNode(validation) {
+    if (!validation || typeof validation !== 'object')
+        return;
+    if (!('min' in validation) && 'gte' in validation) {
+        validation.min = validation.gte;
+    }
+    if (!('max' in validation) && 'lte' in validation) {
+        validation.max = validation.lte;
+    }
+}
+function transformEntityFieldNode(field) {
+    if (!field || typeof field !== 'object')
+        return;
+    transformValidationNode(field.validation);
+    if (Array.isArray(field.items))
+        transformValidationNode(field.items.validation);
+    if (!field.fields || typeof field.fields !== 'object')
+        return;
+    for (const fieldName in field.fields) {
+        transformEntityFieldNode(field.fields[fieldName]);
+    }
+}
+function transformViewNode(view) {
+    if (!view || !Array.isArray(view.parameters))
+        return;
+    view.parameters.forEach((p) => transformValidationNode(p.validation));
+}
+function mergeApiProject(totalProject, fragmentProject, options) {
+    if (totalProject.name != null && fragmentProject.name != null && fragmentProject.name != totalProject.name)
+        throw new Error(`Unable merge project '${fragmentProject.name}' into '${totalProject.name}'`);
+    if (totalProject.version != null &&
+        fragmentProject.version != null &&
+        fragmentProject.version != totalProject.version)
+        throw new Error(`Unable merge project '${fragmentProject.version}' into '${totalProject.version}'`);
+    if (fragmentProject.environmentVariables != null) {
+        totalProject.environmentVariables = totalProject.environmentVariables || {};
+        for (const name in fragmentProject.environmentVariables) {
+            if (name in totalProject.environmentVariables) {
+                switch (options?.environmentVariable?.duplicateNameHandling) {
+                    case 'override':
+                        totalProject.environmentVariables[name] = fragmentProject.environmentVariables[name];
+                        break;
+                    case 'ignore':
+                        break;
+                    default:
+                        throw new Error(`Duplicate environment variables: ${name}. Can config dublicate name handling behavior at options.environmentVariable.duplicateNameHandling`);
+                }
+            }
+            else
+                totalProject.environmentVariables[name] = fragmentProject.environmentVariables[name];
+        }
+    }
+    if (fragmentProject.entities != null) {
+        totalProject.entities = totalProject.entities || [];
+        fragmentProject.entities.forEach((entity) => {
+            const found = totalProject.entities.some((entityInTotal, i) => {
+                if (entityInTotal.name !== entity.name) {
+                    return false;
+                }
+                switch (options?.entity?.duplicateNameHandling) {
+                    case 'override':
+                        totalProject.entities[i] = entity;
+                        return true;
+                    case 'ignore':
+                        return true;
+                    default:
+                        throw new Error('Duplicate entity: ' +
+                            entity.name +
+                            '. Can config dublicate name handling behavior at options.entity.duplicateNameHandling');
+                }
+            });
+            if (found)
+                return;
+            totalProject.entities.push(entity);
+            if (!entity.fields || typeof entity.fields !== 'object')
+                return;
+            for (const fieldName in entity.fields) {
+                transformEntityFieldNode(entity.fields[fieldName]);
+            }
+        });
+    }
+    if (fragmentProject.views != null) {
+        totalProject.views = totalProject.views || {};
+        for (const viewName in fragmentProject.views) {
+            if (viewName in totalProject.views) {
+                switch (options?.view?.duplicateNameHandling) {
+                    case 'override':
+                        totalProject.views[viewName] = fragmentProject.views[viewName];
+                        break;
+                    case 'ignore':
+                        continue;
+                    default:
+                        throw new Error('Duplicate global view: ' +
+                            viewName +
+                            '. Can config dublicate name handling behavior at options.views.duplicateNameHandling');
+                }
+            }
+            else
+                totalProject.views[viewName] = fragmentProject.views[viewName];
+            if (!fragmentProject.views[viewName] || !Array.isArray(fragmentProject.views[viewName])) {
+                delete fragmentProject.views[viewName];
+                continue;
+            }
+            fragmentProject.views[viewName].forEach(transformViewNode);
+        }
+    }
+    for (const name in fragmentProject) {
+        if (name === 'environmentVariables' || name === 'entities' || name === 'views' || name === '$schema')
+            continue;
+        totalProject[name] = fragmentProject[name];
+    }
+    return totalProject;
+}
+export function processMasterFile(basePath, master) {
+    if (master.fragments == null || master.fragments.length == 0)
+        return null;
+    let apiProject = {};
+    master.fragments.forEach((fragment) => {
+        let apiProjectFragment;
+        const fragmentPath = path.join(basePath, fragment.path);
+        common.logInfo('Merging fragment file:', fragmentPath);
+        try {
+            const content = fs.readFileSync(fragmentPath).toString();
+            apiProjectFragment = JSON5.parse(content);
+        }
+        catch (e) {
+            if (fragment.optional) {
+                common.logWarning(fragmentPath, 'not found or unable to parse');
+                return;
+            }
+            common.logError(fragmentPath, 'not found or unable to parse');
+            throw e;
+        }
+        apiProject = mergeApiProject(apiProject, apiProjectFragment, master.options);
+    });
+    apiProject['$schema'] = 'https://schema.siten.vn/mushroom/project.json';
+    if (apiProject.entities == null)
+        apiProject.entities = [];
+    apiProject.entities.forEach((entity) => {
+        if (entity.actions == null)
+            entity.actions = {};
+        for (const actionName in entity.actions) {
+            if ((actionName != 'findMany' && actionName != 'findById') || entity.actions[actionName] == null)
+                continue;
+            entity.actions[actionName].forEach((action) => {
+                if (action.fields) {
+                    action.defaultFields = action.fields.split(',');
+                    delete action.fields;
+                }
+                if (action.allowFields) {
+                    action.returnableFields = action.allowFields.split(',');
+                    delete action.allowFields;
+                }
+                if (actionName !== 'findMany')
+                    return;
+                const findManyAction = action;
+                if (findManyAction.sorting) {
+                    findManyAction.defaultSortings = findManyAction.sorting.split(',').map((f) => {
+                        const c = f.charAt(0);
+                        return {
+                            field: c === '+' || c === '-' ? f.substring(1) : f,
+                            type: c === '-' ? 'Desc' : 'Asc',
+                        };
+                    });
+                    delete findManyAction.sorting;
+                }
+                if (findManyAction.allowSorting) {
+                    findManyAction.allowSortings = findManyAction.allowSorting.split(',').map((f) => {
+                        const c = f.charAt(0);
+                        return {
+                            field: c === '+' || c === '-' ? f.substring(1) : f,
+                            type: c === '-' ? 'Desc' : c === '+' ? 'Asc' : 'Both',
+                        };
+                    });
+                    delete findManyAction.allowSorting;
+                }
+            });
+        }
+    });
+    return apiProject;
+}

package/dist/merge.js

@@ -0,0 +1,70 @@
+import fs from 'fs';
+import path from 'path';
+import JSON5 from 'json5';
+import * as common from './common.js';
+import help from './help.js';
+import * as masterFile from './master-file/master-file.js';
+export default async function merge(args) {
+    let projectName = args[1];
+    const output = args[2];
+    if (!projectName || !output) {
+        help(args);
+        return;
+    }
+    let alias = 'default';
+    const atIndex = projectName.indexOf('@');
+    if (atIndex !== -1) {
+        alias = projectName.substring(atIndex + 1);
+        projectName = projectName.substring(0, atIndex);
+        if (!projectName) {
+            help(args);
+            return;
+        }
+        if (!alias)
+            alias = 'default';
+    }
+    let mushroomConfig;
+    try {
+        const mushroomConfigContent = fs.readFileSync('./mushroom-config.json').toString();
+        mushroomConfig = JSON.parse(mushroomConfigContent);
+    }
+    catch (e) {
+        common.logError('mushroom-config.json not found or unable to parse');
+        throw e;
+    }
+    if (!mushroomConfig || typeof mushroomConfig !== 'object')
+        throw new Error(`Invalid configuration. Please re-check file mushroom-config.json`);
+    if (!mushroomConfig || !mushroomConfig.projects || !mushroomConfig.projects[projectName])
+        throw new Error(`Project not found (${projectName})`);
+    const project = mushroomConfig.projects[projectName];
+    if (!project.src)
+        throw new Error('Project source (src) not found');
+    let master;
+    try {
+        const sourceContent = fs.readFileSync(project.src).toString();
+        master = JSON5.parse(sourceContent);
+    }
+    catch (e) {
+        common.logError(project.src, 'not found or unable to parse');
+        throw e;
+    }
+    if (!master || typeof master !== 'object')
+        throw new Error(`Invalid api project configuration. Please re-check file ${project.src}`);
+    let projectApi = null;
+    if (Array.isArray(master.fragments)) {
+        common.logInfo('Process master file:', project.src);
+        projectApi = masterFile.processMasterFile(path.dirname(project.src), master);
+    }
+    else {
+        projectApi = master;
+    }
+    if (!projectApi || typeof projectApi !== 'object') {
+        throw new Error(`Invalid api project configuration. Please re-check file ${project.src}`);
+    }
+    if (projectApi.name !== projectName) {
+        throw new Error(`Project name is mismatched (${projectName} & ${projectApi.name})`);
+    }
+    common.ensureFolder(output);
+    fs.writeFileSync(output, JSON.stringify(projectApi, null, master.options?.formatIndent ? '  ' : undefined));
+    common.logInfo(`Merged ${projectName}@${alias} then saved to ${output}`);
+}

package/dist/mr.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import * as common from './common.js';
+import init from './init.js';
+import config from './config.js';
+import gen from './gen.js';
+import merge from './merge.js';
+import update from './update.js';
+import help from './help.js';
+import checkUpdate from './check-update.js';
+const packageVersion = common.getPackageVersion();
+const versionGroup = packageVersion.match(/([^-]+)(-(\w+).*)?/);
+const currentDistTag = versionGroup?.[3] ? versionGroup[3] : 'latest';
+common.logInfo('Mushroom CLI version', packageVersion);
+async function run(args) {
+    let debugMode = false;
+    if (args.indexOf('--debug') !== -1) {
+        debugMode = true;
+        args = args.filter((arg) => arg !== '--debug');
+    }
+    let checkUpdateTask;
+    if (args.indexOf('--no-check-update') !== -1) {
+        args = args.filter((arg) => arg !== '--no-check-update');
+        checkUpdateTask = null;
+    }
+    else {
+        checkUpdateTask = checkUpdate();
+        checkUpdateTask.catch(() => { });
+    }
+    const startTime = new Date().getTime();
+    try {
+        switch (args[0]) {
+            case 'init':
+                await init(args);
+                break;
+            case 'config':
+                await config(args);
+                break;
+            case 'gen':
+                await gen(args);
+                break;
+            case 'merge':
+                merge(args);
+                break;
+            case 'update':
+                await update(args);
+                break;
+            case 'help':
+            case 'man':
+                help(args.slice(1).join());
+                break;
+            default:
+                help(args, true);
+                break;
+        }
+    }
+    catch (e) {
+        common.logError(debugMode ? e : 'ERROR: ' + e.message);
+    }
+    finally {
+        common.logInfo('Processed in', new Date().getTime() - startTime, 'ms.');
+    }
+    if (checkUpdateTask !== null)
+        try {
+            const data = await checkUpdateTask;
+            if (data['dist-tags'] &&
+                data['dist-tags'][currentDistTag] &&
+                data['dist-tags'][currentDistTag] !== packageVersion) {
+                common.logWarning(`YOUR mushroom-cli VERSION IS NOT LATEST (dist-tags: ${currentDistTag}). PLEASE RUN: npm i mushroom-cli@${data['dist-tags'][currentDistTag]} OR yarn add mushroom-cli@^${data['dist-tags'][currentDistTag]}`);
+            }
+        }
+        catch (e) {
+            if (debugMode)
+                common.logError(e);
+        }
+}
+const [, , ...args] = process.argv;
+run(args);

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/update/tsCode.js

@@ -0,0 +1,82 @@
+import fs from 'fs';
+import fetch from 'node-fetch';
+import * as common from '../common.js';
+export default async function updateTsCode(options) {
+    if (options.input || options.output) {
+        if (!options.output) {
+            common.logError('Missing output file path');
+            return;
+        }
+        if (!options.input) {
+            common.logError('Missing remote url');
+            return;
+        }
+        pullAsync({
+            action: 'pull',
+            source: options.input,
+            destination: options.output,
+        });
+        common.logInfo('Finish update ts-code');
+        return;
+    }
+    if (!fs.existsSync('mushroom-config.json')) {
+        common.logError('Missing mushroom-config.json file');
+        return;
+    }
+    const configJson = fs.readFileSync('mushroom-config.json').toString();
+    const config = JSON.parse(configJson);
+    if (!config.update) {
+        common.logError("Missing 'update' in mushroom-config.json file");
+        return;
+    }
+    if (!config.update['ts-code']) {
+        common.logError("Missing 'update.ts-code' in mushroom-config.json file");
+        return;
+    }
+    const steps = config.update['ts-code'].steps;
+    if (!steps) {
+        common.logError("Missing 'update.ts-code.steps' in mushroom-config.json file");
+        return;
+    }
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        const actionName = step.action;
+        switch (actionName) {
+            case 'pull':
+                await pullAsync(step);
+                break;
+            case 'replace-content':
+                replaceContent(step);
+                break;
+            case 'replace-regex':
+                replaceRegex(step);
+                break;
+            default:
+                common.logWarning('Unsupported step action:', actionName);
+                break;
+        }
+    }
+    common.logInfo('Finish update ts-code');
+}
+async function pullAsync(step) {
+    common.logInfo('Fetch', step.source);
+    const res = await fetch(step.source);
+    common.logInfo('Write to', step.destination);
+    fs.writeFileSync(step.destination, await res.text());
+}
+function replaceContent(step) {
+    common.logInfo('Replace', step.search, 'by', step.replacement, 'in', step.source, 'file');
+    const content = fs.readFileSync(step.source).toString();
+    if (!content)
+        return;
+    const output = content.replace(new RegExp(step.search.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), step.replacement);
+    fs.writeFileSync(step.source, output);
+}
+function replaceRegex(step) {
+    common.logInfo('Replace pattern', step.pattern, 'by', step.replacement, 'in', step.source, 'file');
+    const content = fs.readFileSync(step.source).toString();
+    if (!content)
+        return;
+    const output = content.replace(new RegExp(step.pattern, 'g'), step.replacement);
+    fs.writeFileSync(step.source, output);
+}

package/dist/update.js

@@ -0,0 +1,20 @@
+import help from './help.js';
+import updateTsCode from './update/tsCode.js';
+export default async function update(args) {
+    const command = args[1];
+    switch (command) {
+        case 'ts-code':
+            await updateTsCode({
+                input: args[3],
+                output: args[2],
+            });
+            break;
+        case 'help':
+        case 'man':
+            help(args);
+            break;
+        default:
+            help(args, true);
+            break;
+    }
+}

package/package.json

@@ -1,28 +1,64 @@
-{
-  "name": "mushroom-cli",
-  "version": "1.2.0-alpha.8",
-  "description": "Mushroom CLI",
-  "main": "mr.js",
-  "scripts": {
-    "release": "npm publish --access public --tag alpha"
-  },
-  "keywords": [
-    "Mushroom",
-    "CLI"
-  ],
-  "bin": {
-    "mushroom-cli": "mr.js",
-    "mr": "mr.js"
-  },
-  "author": "suco2007",
-  "license": "ISC",
-  "dependencies-comments": "node-fetch: 2.x; open: 8.x",
-  "dependencies": {
-    "jsdom": "^22.1.0",
-    "json5": "^2.2.3",
-    "node-fetch": "^2.6.11",
-    "open": "^8.4.2",
-    "readline-sync": "^1.4.10",
-    "targz": "^1.0.1"
-  }
-}
+{
+  "name": "mushroom-cli",
+  "version": "1.2.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"
+  },
+  "lint-staged": {
+    "!(*.ts)": "prettier --write --ignore-unknown",
+    "src/**/*.ts": [
+      "eslint --quiet",
+      "prettier --write"
+    ]
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "Mushroom",
+    "CLI"
+  ],
+  "bin": {
+    "mushroom-cli": "dist/mr.js",
+    "mr": "dist/mr.js"
+  },
+  "author": "suco2007",
+  "license": "ISC",
+  "dependencies": {
+    "jsdom": "^26.1.0",
+    "json5": "^2.2.3",
+    "minify": "^14.0.0",
+    "node-fetch": "^3.3.2",
+    "open": "^10.1.2",
+    "readline-sync": "^1.4.10",
+    "targz": "^1.0.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.28.0",
+    "@types/jsdom": "^21.1.7",
+    "@types/minify": "^9.1.4",
+    "@types/node": "^22.15.29",
+    "@types/node-fetch": "^2.6.12",
+    "@types/readline-sync": "^1.4.8",
+    "@types/targz": "^1.0.5",
+    "copyfiles": "^2.4.1",
+    "eslint": "^9.28.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.1.0",
+    "only-allow": "^1.2.1",
+    "prettier": "^3.5.3",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.33.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/check-update.js

@@ -1,9 +0,0 @@
-const fetch = require('node-fetch');
-
-
-function checkUpdate() {
-    return fetch('https://registry.npmjs.org/mushroom-cli/')
-        .then(res => res.json());
-}
-
-module.exports = checkUpdate;