@common-stack/generate-plugin 6.0.6-alpha.7 → 6.0.6-alpha.71

package/src/generators/add-fullstack/updates/licenseUpdate.ts

@@ -0,0 +1,23 @@
+import { Tree, readJson } from '@nx/devkit';
+import * as path from 'path';
+
+export function updateLicense(tree: Tree, projectRoot: string) {
+    const files = ['LICENSE-GNU', 'LICENSE-IST', 'LICENSE-MIT'];
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    const packageJson = readJson(tree, packageJsonPath);
+    
+    if (packageJson.license) {
+        const fileName = `LICENSE-${packageJson.license.toUpperCase()}`;
+        
+        files.forEach(file => {
+            const filePath = path.join(projectRoot, file);
+            if (file === fileName) {
+                if (tree.exists(filePath)) {
+                    tree.rename(filePath, path.join(projectRoot, 'LICENSE'));
+                }
+            } else {
+                tree.delete(filePath);
+            }
+        });
+    }
+}

package/src/generators/add-fullstack/updates/packageJsonUpdate.ts

@@ -1,11 +1,52 @@
 import { Tree, updateJson } from '@nx/devkit';
 import * as path from 'path';
+import { convertHttpsToSsh } from '../../../utils';
 
-export function updatePackageJson(tree: Tree, projectRoot: string, name: string) {
+export function updatePackageJson(tree: Tree, projectRoot: string, json: any) {
     const packageJsonPath = path.join(projectRoot, 'package.json');
-    updateJson(tree, packageJsonPath, (packageJson) => {
-        packageJson['name'] = name;
-        // You can add more custom logic here if needed
+    
+    updateJson(tree, packageJsonPath, (packageJson: any) => {
+        Object.entries(json).reduce((acc, [key, value]) => { 
+            acc[key] = value; 
+            return acc; 
+        }, packageJson);
         return packageJson;
     });
 }
+
+export function updateRepository(tree: Tree, projectRoot: string, repository: string) {
+    if (repository.startsWith('http://')) {
+        repository = repository.replace('http://', 'https://');
+    }
+
+    // update in package.json
+    updatePackageJson(tree, projectRoot, {
+        "homepage": `${repository}#readme`,
+        "bugs": {
+            "url": `${repository}/issues`
+        },
+        "repository": {
+            "type": "git",
+            "url": `git+${repository}.git`
+        },
+    });
+    
+    // update in Jenkinsfile
+    const filePath = path.join(projectRoot, 'Jenkinsfile');
+    
+    if (tree.exists(filePath)) {
+        const jenkinsFileContent = tree.read(filePath).toString();
+        let paramExists = false;
+        const updatedContent = jenkinsFileContent.split('\n').map(line => {
+            if (line.includes(`string(name: 'REPOSITORY_SSH_URL'`)) {
+                paramExists = true;
+                return line.replace(/defaultValue: '.*'/, `defaultValue: '${convertHttpsToSsh(repository)}'`);
+            }
+            return line;
+        }).join('\n');
+
+        if (paramExists) {
+            tree.write(filePath, updatedContent);
+        }
+    }
+}

package/src/generators/add-moleculer/files/charts/chart/Chart.yaml

@@ -5,5 +5,5 @@ version: v0.1.3
 
 dependencies:
 - name: cdebase
-  version: "v0.1.9"
+  version: "v0.1.13"
   repository: "https://cdmbase.github.io/helm-chart/helm-packages"

package/src/generators/add-moleculer/files/package.json

@@ -25,11 +25,11 @@
         "watch": "npm run start:dev"
     },
     "dependencies": {
-        "@common-stack/client-core": "6.0.6-alpha.5",
-        "@common-stack/core": "6.0.6-alpha.5",
-        "@common-stack/server-core": "6.0.6-alpha.5",
-        "@common-stack/server-stack": "6.0.6-alpha.5",
-        "@common-stack/store-mongo": "6.0.6-alpha.5",
+        "@common-stack/client-core": "6.0.6-alpha.61",
+        "@common-stack/core": "6.0.6-alpha.50",
+        "@common-stack/server-core": "6.0.6-alpha.50",
+        "@common-stack/server-stack": "6.0.6-alpha.69",
+        "@common-stack/store-mongo": "6.0.6-alpha.50",
         "@container-stack/mailing-api": "5.2.1-alpha.1",
         "helmet": "^3.21.2",
         "react": "18.2.0",

package/src/generators/add-moleculer/generator.spec.ts

@@ -6,7 +6,7 @@ import { AddMoleculerGeneratorSchema } from './schema';
 
 describe('add-moleculer generator', () => {
     let tree: Tree;
-    const options: AddMoleculerGeneratorSchema = { name: 'test', directory: 'lib' };
+    const options: AddMoleculerGeneratorSchema = { ns: 'sample', name: 'test', directory: 'lib' };
 
     beforeEach(() => {
         tree = createTreeWithEmptyWorkspace();

package/src/generators/add-moleculer/generator.ts

@@ -3,18 +3,23 @@ import * as path from 'path';
 import { AddMoleculerGeneratorSchema } from './schema';
 import { isValid, getValid } from '../../utils';
 
+const DEFAULT_SERVER_NAME = 'moleculer-server';
+
 export async function addMoleculerGenerator(tree: Tree, options: AddMoleculerGeneratorSchema) {
-    const configs: any = {...options};
+    const projectName = isValid(options.name) ? `${getValid(options.name)}-server` : DEFAULT_SERVER_NAME;
+    const configs: any = {...options, name: projectName};
+
     return await generateMoleculer(tree, configs);
 }
 
 export const generateMoleculer = async (tree: Tree, options: any) => {
-    const projectName = getValid(options.name) ?? 'moleculer-server';
+    let projectName = getValid(options.name) ?? DEFAULT_SERVER_NAME;
     const projectRoot = isValid(options.directory) ? `${getValid(options.directory)}/${projectName}` : projectName;
+    projectName = isValid(options.ns) ? `${getValid(options.ns)}-${projectName}` : projectName;
 
     generateFiles(tree, path.join(__dirname, 'files'), projectRoot, options);
     updateJson(tree, `${projectRoot}/package.json`, (packageJson) => {
-        packageJson['name'] = options.name;
+        packageJson['name'] = projectName;
         return packageJson;
     });
 

package/src/generators/add-moleculer/schema.d.ts

@@ -1,4 +1,5 @@
 export interface AddMoleculerGeneratorSchema {
-    name: string;
+    ns: string;
     directory: string;
+    name: string;
 }

package/src/generators/add-moleculer/schema.json

@@ -4,16 +4,21 @@
     "title": "",
     "type": "object",
     "properties": {
-        "name": {
+        "ns": {
             "type": "string",
-            "description": "",
-            "x-prompt": "What name would you like to use?"
+            "description": "The project namespace",
+            "x-prompt": "What namespace would you like to use?"
         },
         "directory": {
             "type": "string",
             "description": "",
             "x-prompt": "What directory would you like to create in?"
+        },
+        "name": {
+            "type": "string",
+            "description": "The module name",
+            "x-prompt": "What name would you like to use for this moleculer server module?"
         }
     },
-    "required": ["name", "directory"]
+    "required": ["ns", "directory", "name"]
 }

package/src/generators/{add-core-package → add-package}/generator.spec.ts

@@ -1,19 +1,19 @@
 import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing';
 import { Tree, readProjectConfiguration } from '@nx/devkit';
 
-import { addCorePackageGenerator } from './generator';
-import { AddCorePackageGeneratorSchema } from './schema';
+import { addPackageGenerator } from './generator';
+import { AddPackageGeneratorSchema } from './schema';
 
-describe('add-core-package generator', () => {
+describe('add-package generator', () => {
     let tree: Tree;
-    const options: AddCorePackageGeneratorSchema = { name: 'test', directory: 'lib' };
+    const options: AddPackageGeneratorSchema = { name: 'test', directory: 'lib' };
 
     beforeEach(() => {
         tree = createTreeWithEmptyWorkspace();
     });
 
     it('should run successfully', async () => {
-        await addCorePackageGenerator(tree, options);
+        await addPackageGenerator(tree, options);
         const config = readProjectConfiguration(tree, 'test');
         expect(config).toBeDefined();
     });

package/src/generators/add-package/generator.ts

@@ -0,0 +1,62 @@
+import { addProjectConfiguration, formatFiles, generateFiles, Tree, updateJson } from '@nx/devkit';
+import * as path from 'path';
+import { AddPackageGeneratorSchema } from './schema';
+import { isValid, getValid } from '../../utils';
+import { processFiles } from '../../utils/filesConfig';
+import { syncConfig } from '../../utils/syncConfig';
+
+export async function addPackageGenerator(tree: Tree, options: AddPackageGeneratorSchema) {
+    if (!isValid(options.name)) {
+        console.error('Package name can not be empty, please try again!');
+        return;
+    }
+
+    const packages = ['core', 'client', 'browser', 'server'];
+    const packageType = getValid(options.packageType);
+    if (packageType && packageType.toLocaleLowerCase() !== 'all') {
+        if(!packages.includes(packageType)) {
+            console.error('Package type is not available! please choice in Client|Browser|Core|Server|All');
+            return;
+        }
+        generatePackage(tree, {...options, type: packageType.toLocaleLowerCase()}, true);
+    } else {
+        packages.forEach(pkg => {
+            const configs: any = {...options, type: pkg};
+            generatePackage(tree, configs, true);
+        });
+    }
+
+    await formatFiles(tree);
+}
+
+// export const generateModule = async (tree: Tree, options: any) => {
+//     for (const [packageName, packageConfig] of Object.entries(options)) {
+//         const configs: any = {...options, ...(packageConfig as any)};
+//         configs.type = packageName;
+//         generatePackage(tree, configs, false);
+//     }
+    
+//     await formatFiles(tree);
+// }
+
+export const generatePackage = async (tree: Tree, options: any, cmdLine: boolean = false) => {
+    const basePath = `${options.name}/${options.type}`;
+    const packageRoot = isValid(options.directory) ? `${getValid(options.directory)}/${basePath}` : basePath;
+    const baseName = isValid(options.name) ? `${options.name}-${options.type}` : options.type;
+    const packageName = isValid(options.ns) ? `${getValid(options.ns)}-${baseName}` : baseName;
+
+    generateFiles(tree, path.join(__dirname, 'files', options.type), packageRoot, options);
+    updateJson(tree, `${packageRoot}/package.json`, (packageJson) => {
+        packageJson['name'] = packageName;
+        return packageJson;
+    });
+
+    if (cmdLine) {
+        syncConfig(tree, packageRoot, options);
+    } else {
+        processFiles(tree, packageRoot, options);
+        await formatFiles(tree);
+    }
+}
+
+export default addPackageGenerator;

package/src/generators/add-package/schema.d.ts

@@ -0,0 +1,6 @@
+export interface AddPackageGeneratorSchema {
+    name: string;
+    directory: string;
+    ns?: string;
+    packageType?: string;
+}

package/src/generators/add-package/schema.json

@@ -0,0 +1,29 @@
+{
+    "$schema": "https://json-schema.org/schema",
+    "$id": "AddPackage",
+    "title": "",
+    "type": "object",
+    "properties": {
+        "ns": {
+            "type": "string",
+            "description": "The project namespace(optional)",
+            "x-prompt": "What namespace would you like to use?(optional)"
+        },
+        "name": {
+            "type": "string",
+            "description": "",
+            "x-prompt": "What name would you like to use to this module?"
+        },
+        "directory": {
+            "type": "string",
+            "description": "",
+            "x-prompt": "What directory would you like to create in?"
+        },
+        "packageType": {
+            "type": "string",
+            "description": "",
+            "x-prompt": "What type of package would you like to create in Client|Browser|Core|Server|All?(default: All)"
+        }
+    },
+    "required": ["name", "directory"]
+}

package/src/index.ts

@@ -2,9 +2,6 @@ export * from './generators/add-frontend/generator';
 export * from './generators/add-backend/generator';
 export * from './generators/add-fullstack/generator';
 export * from './generators/add-moleculer/generator';
-export * from './generators/add-browser-package/generator';
-export * from './generators/add-client-package/generator';
-export * from './generators/add-core-package/generator';
-export * from './generators/add-server-package/generator';
+export * from './generators/add-package/generator';
 export { default as updateDeployVersion } from './executors/update-deploy-version/executor';
 export { default as sortPackageJson } from './executors/sort-package-json/executor';

package/src/utils/filesConfig.ts

@@ -0,0 +1,84 @@
+import { Tree } from '@nx/devkit';
+import * as fs from 'node:fs';
+import * as path from 'path';
+import { deepMerge } from '@common-stack/rollup-vite-utils/lib/utils/setupConfig.cjs';
+
+export const processFiles = (tree: Tree, projectRoot: string, options: any) => {
+    if (options.files && Object.entries(options.files).length > 0) {
+        for (const [fileName, addContent] of Object.entries(options.files)) {
+            switch (fileName) {
+                case 'config/env-config.ts':
+                    updateEnvConfigFile(tree, projectRoot, addContent);
+                    break;
+                case 'cdm-locales':
+                    addLocalesFile(tree, projectRoot, addContent);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+}
+
+const updateEnvConfigFile = (tree: Tree, projectRoot: string, jsonContent: any) => {
+    const filePath = path.join(projectRoot, 'src/config/env-config.ts');
+    if (tree.exists(filePath)) {
+        try {
+            let fileContent: string = tree.read(filePath).toString();
+            let additionalContent: string = ',';
+
+            for (const [key, val] of Object.entries(jsonContent)) {
+                if (typeof val === 'string') {
+                    additionalContent += `${key}: str({ default: '${val}' }),\n`;
+                } else {
+                    additionalContent += `${key}: ${(val as any).type}(${JSON.stringify((val as any).value)}),\n`;
+                }
+            }
+            additionalContent = additionalContent.substring(1);
+            console.log('Changing the env-config file with {', additionalContent, '}');
+            
+            const lines = fileContent.split(/\n/);
+            let idx;
+            for (idx = lines.length - 1; idx >= 0; idx--) {
+                if (lines[idx].trim() === '});') {
+                    break;
+                }
+            }
+            
+            if (idx > 0) {
+                const newLines = [
+                    ...lines.slice(0, idx),
+                    additionalContent,
+                    ...lines.slice(idx),
+                ];
+                fileContent = newLines.join('\n');
+            }
+
+            tree.write(filePath, fileContent);
+        } catch(e) {
+            console.error('Failed to change env-config', e);
+        }
+    } else {
+        console.log('No exist env-config file at ', filePath);
+    }
+}
+
+const addLocalesFile = async(tree: Tree, projectRoot: string, jsonContent: any) => {
+    try {
+        for (const [dirName, filesContent] of Object.entries(jsonContent)) {
+            const dirPath = path.join(projectRoot, 'src/cdm-locales', dirName);
+            for (const [fileName, fileContent] of Object.entries(filesContent)) {
+                const filePath = path.join(dirPath, fileName);
+                if (!tree.exists(filePath)) {
+                    tree.write(filePath, JSON.stringify(fileContent, null, 2));
+                } else {
+                    let newContent = tree.read(filePath).toJSON();
+                    newContent = deepMerge(newContent, fileContent);
+                    tree.write(filePath, JSON.stringify(newContent, null, 2));
+                }
+            }
+        }
+    } catch (e) {
+        console.error(e);
+    }
+}

package/src/utils/index.ts

@@ -1,4 +1,6 @@
+import { Tree } from '@nx/devkit';
 import * as fs from 'node:fs';
+import * as path from 'path';
 
 export const resetProject = (rootDir: string) => {
     if (fs.existsSync(`${rootDir}/project.json`)) {
@@ -16,3 +18,32 @@ export const isValid = (val: string) => {
 export const getValid = (val: string) => {
     return val ? val.trim() : null;
 }
+
+export const convertHttpsToSsh = (url) => {
+    const httpsPattern = /^https:\/\/(.+?)\/(.+?)\/(.+?)(\.git)?$/;
+
+    const match = url.match(httpsPattern);
+
+    if (match) {
+        const domain = match[1];
+        const user = match[2];
+        const repo = match[3];
+        
+        return `git@${domain}:${user}/${repo}.git`;
+    } else {
+        throw new Error("Invalid HTTPS URL format");
+    }
+}
+
+export const readDir = (tree: Tree, dirPath: string) => {
+    const files = tree.children(dirPath);
+    const result = {};
+    files.forEach(file => {
+        if (tree.isFile(path.join(dirPath, file))) {
+            result[file] = JSON.parse(tree.read(path.join(dirPath, file)).toString());
+        } else {
+            result[file] = readDir(tree, path.join(dirPath, file));
+        }
+    });
+    return result;
+}

package/src/utils/syncConfig.ts

@@ -0,0 +1,128 @@
+import { Tree, updateJson } from '@nx/devkit';
+import * as path from 'path';
+import { parse } from '@babel/parser';
+import traverse from '@babel/traverse';
+import { set } from 'lodash';
+import { getValid, readDir } from './index';
+
+export interface SyncConfigOptions {
+    name: string;
+    type: string;
+    directory: string;
+    ns?: string;
+}
+
+const DEFAULT_PACKAGE = 'core';
+
+export const syncConfig = (tree: Tree, projectRoot: string, options: SyncConfigOptions) => {
+    // synchronize package in package.json and lerna.json
+    syncPackage(tree, options);
+
+    const configPath = 'cde-config.json';
+    if (tree.exists(configPath)) {
+        try {
+            const directory = getValid(options.directory) ?? 'packages';
+            const type = getValid(options.type) ?? DEFAULT_PACKAGE;
+            const moduleName = options.name; // name should not be null
+    
+            const envConfigContent = getEnvConfigFileContent(tree, projectRoot);
+            const localesContent = getLocalesFileContent(tree, projectRoot);
+            const packageContent = {
+                type: `packages-${type}`,
+                files: {
+                    "config/env-config.ts": envConfigContent ?? {},
+                    "cdm-locales": localesContent ?? {},
+                },
+            };
+
+            updateJson(tree, configPath, (config: any) => {
+                set(config, [directory, 'modules', moduleName, type], packageContent);
+                return config;
+            });
+        } catch(e) {
+            console.error('Failed to change env-config', e);
+        }
+    } else {
+        console.log('No exist env-config file at ', path.join(tree.root, configPath));
+    }
+}
+
+const getEnvConfigFileContent = (tree: Tree, projectRoot: string) => {
+    const filePath = path.join(projectRoot, 'src/config/env-config.ts');
+    if (tree.exists(filePath)) {
+        try {
+            const result = {};
+            let fileContent: string = tree.read(filePath).toString();
+            const ast = parse(fileContent, {
+                sourceType: 'module',
+                plugins: ['typescript', 'dynamicImport'],
+            });
+            (traverse as any).default(ast, {
+                enter(astroPath) {
+                    if (astroPath.node.type === "VariableDeclarator" && astroPath.node.id.name === "config") {
+                        astroPath.node.init.arguments[1].properties.forEach(prop => {
+                            const key = prop.key.name;
+                            const callee = prop.value.callee.name;
+                            let value: any;
+                            if (prop.value.arguments && prop.value.arguments.length > 0) {
+                                value = {};
+                                prop.value.arguments[0].properties.forEach(p => {
+                                    if (p.value.elements && p.value.elements.length > 0) {
+                                        value[p.key.name] = [];
+                                        p.value.elements.forEach(ele => value[p.key.name].push(ele.value));
+                                    } else {
+                                        value[p.key.name] = callee == 'json' ? JSON.parse(p.value.value) : p.value.value;
+                                    }
+                                });
+                            } else {
+                                value = '';
+                            }
+                            console.log(`${key}:`, `${callee}(${JSON.stringify(value)})`);
+                            result[key] = { type: callee, value: value };
+                        });
+                    }
+                },
+            });
+            return result;
+        } catch(e) {
+            console.error('Failed to change env-config', e);
+        }
+    } else {
+        console.log('No exist env-config file at ', filePath);
+    }
+    return null;
+}
+
+const getLocalesFileContent = (tree: Tree, projectRoot: string) => {
+    const dirPath = path.join(projectRoot, 'src/cdm-locales');
+    if (tree.exists(dirPath)) {
+        try {
+            return readDir(tree, dirPath);
+        } catch (e) {
+            console.error(e);
+        }
+    } else {
+        console.log('No exist cdm-locales directory at ', dirPath);
+    }
+    return null;
+}
+
+export const syncPackage = (tree: Tree, options: any) => {
+    const directory = getValid(options.directory) ?? 'packages';
+
+    updateJson(tree, 'package.json', (packageJson: any) => {
+        const packages = packageJson.workspaces?.packages || [];
+        if (!packages.includes(`${directory}/*`)) {
+            packageJson.workspaces.packages.push(`${directory}/*`);
+        }
+        return packageJson;
+    });
+
+    updateJson(tree, 'lerna.json', (lernaJson: any) => {
+        const packages = lernaJson.packages || [];
+        if (!packages.includes(`${directory}/*`)) {
+            lernaJson.packages.push(`${directory}/*`);
+        }
+        return lernaJson;
+    });
+}

package/lib/constants/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sources":["../../src/constants/index.ts"],"sourcesContent":[null],"names":[],"mappings":"aAAO,MAAM,eAAe,GAAG,QAAQ;AAChC,MAAM,kBAAkB,GAAG,WAAW;AACtC,MAAM,oBAAoB,GAAG"}

package/lib/constants/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","sources":["../../src/constants/index.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAO,MAAM,eAAe,GAAG,QAAQ;AAChC,MAAM,kBAAkB,GAAG,WAAW;AACtC,MAAM,oBAAoB,GAAG"}

package/lib/generators/add-browser-package/files/jest.config.js

@@ -1,8 +0,0 @@
-const base = require('../../../jest.config.base');
-const packageJson = require('./package');
-
-module.exports = {
-    ...base,
-    name: packageJson.name,
-    displayName: packageJson.name,
-};

package/lib/generators/add-browser-package/files/package.json

@@ -1,49 +0,0 @@
-{
-    "name": "browser-package",
-    "version": "3.1.1-alpha.6",
-    "description": "Sample core for higher packages to depend on",
-    "license": "ISC",
-    "author": "CDMBase LLC",
-    "type": "module",
-    "main": "lib/index.js",
-    "module": "lib/index.js",
-    "typings": "lib/index.d.ts",
-    "scripts": {
-        "build": "npm run build:clean && npm run build:lib",
-        "build:clean": "rimraf lib",
-        "build:lib": "rollup -c rollup.config.mjs",
-        "build:lib:watch": "npm run build:lib -- --watch",
-        "jest": "./node_modules/.bin/jest",
-        "prepublish": "npm run build",
-        "schema:download": "./node_modules/.bin/apollo-codegen download-schema http://localhost:8080/graphql --output schema.json ",
-        "schema:generate": "./node_modules/.bin/apollo-codegen generate src/browser/graphql/**/*.gql --schema schema.json --target typescript --output src/browser/graphql/schema.ts",
-        "test": "cross-env ENV_FILE=../../config/test/test.env jest",
-        "test:debug": "npm test -- --runInBand",
-        "test:watch": "npm test -- --watch",
-        "watch": "npm run build:lib:watch"
-    },
-    "dependencies": {
-        "envalid": "~7.2.2",
-        "pluralize": "8.0.0",
-        "react-csv": "^2.0.3"
-    },
-    "peerDependencies": {
-        "@cdm-logger/client": "*",
-        "@common-stack/client-react": "6.0.6-alpha.5",
-        "@remix-run/react": "*",
-        "antd": ">=5.1.6",
-        "lodash": "*",
-        "moment": "*",
-        "react": "*",
-        "react-redux": "*",
-        "redux": ">=4.0.1",
-        "redux-observable": "*",
-        "rxjs": "*"
-    },
-    "publishConfig": {
-        "access": "public"
-    },
-    "typescript": {
-        "definition": "lib/index.d.ts"
-    }
-}