@common-stack/generate-plugin 6.0.6-alpha.1 → 6.0.6-alpha.100

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

@@ -5,31 +5,56 @@ import * as path from 'path';
 import * as fs from 'fs';
 import { AddFullstackGeneratorSchema } from './schema';
 import { getValid, isValid } from '../../utils';
-import { updateJenkinsFile, updatePackageJson } from './updates';
+import { 
+    updateJenkinsFile,
+    updatePackageJson,
+    backupLernaJson,
+    restoreLernaJson,
+    updateHtmlPlugin,
+    updateLicense,
+    backupFiles,
+    restoreFiles,
+    updateRepository,
+} from './updates';
 import {
     generateBackend,
     generateFrontend,
     generateMoleculer,
-    generateBrowserPackage,
-    generateClientPackage,
-    generateCorePackage,
-    generateServerPackage,
+    generatePackage,
 } from '../../index';
 
 export async function addFullstackGenerator(tree: Tree, options: AddFullstackGeneratorSchema) {
     const basePath = options.path || '';
-    const projectRoot = path.join(basePath, getValid(options.name) ?? 'fullstack-pro');
+    const projectName = getValid(options.name) ?? 'fullstack-pro';
+    const projectRoot = path.join(basePath, projectName);
 
     console.log(`basePath: ${basePath}`);
 
+    // backup existing lerna values
+    const lernaBackup = backupLernaJson(tree, projectRoot);
+
+    // backup files codegen.yaml
+    const filesToBackup = ['codegen.yml', 'values-dev.yaml', 'values-prod.yaml', 'values-stage.yaml'];
+    const filesBackup = backupFiles(tree, projectRoot, filesToBackup);
+
     generateFiles(tree, path.join(__dirname, 'files'), projectRoot, options);
 
     // Update Jenkinsfile with dynamic values
-    const jenkinsFilePath = path.join(projectRoot, 'Jenkinsfile');
-    updateJenkinsFile(jenkinsFilePath, options.name);
+    updateJenkinsFile(tree, projectRoot, projectName);
 
     // Update package.json with the project name
-    updatePackageJson(tree, projectRoot, getValid(options.name));
+    updatePackageJson(tree, projectRoot, { name: projectName });
+
+    // Update tools/html-plugin-template
+    updateHtmlPlugin(tree, projectRoot);
+
+    if (lernaBackup) {
+        // When update the existing lerna.json, it shouldn't overwrite version, allowbranch, packages
+        restoreLernaJson(tree, projectRoot, lernaBackup);
+    }
+
+    // Restore files backup to ignore update
+    restoreFiles(tree, projectRoot, filesBackup);
 
     await formatFiles(tree);
 
@@ -37,9 +62,9 @@ export async function addFullstackGenerator(tree: Tree, options: AddFullstackGen
         const configPath = path.resolve(basePath, getValid(options.config));
         if (fs.existsSync(configPath)) {
             try {
-                const content = String(fs.readFileSync(configPath));
-                const configs = JSON.parse(content);
+                const configs = JSON.parse(fs.readFileSync(configPath).toString());
                 configs.parent = projectRoot;
+                configs.ns = projectName;
 
                 await processConfigs(tree, configs);
             } catch (error) {
@@ -47,14 +72,17 @@ export async function addFullstackGenerator(tree: Tree, options: AddFullstackGen
             }
         }
     }
-}
 
+    // Update license from package.json
+    updateLicense(tree, projectRoot);
+}
 
-const generateServers = async (tree: Tree, parent: string, servers: any) => {
-    for (const [serverName, serverConfig] of Object.entries(servers)) {
+const generateServers = async (tree: Tree, options: any) => {
+    for (const [serverName, serverConfig] of Object.entries(options.servers)) {
         const configs: any = serverConfig;
         configs.name = serverName;
-        configs.directory = path.join(parent, 'servers');
+        configs.directory = path.join(options.parent, 'servers');
+        configs.ns = options.ns;
 
         switch (configs?.type) {
             case 'frontend':
@@ -72,38 +100,36 @@ const generateServers = async (tree: Tree, parent: string, servers: any) => {
     }
 };
 
-const generatePackages = async (tree: Tree, parent: string, packages: any) => {
-    for (const [packageName, packageConfig] of Object.entries(packages)) {
-        const configs: any = packageConfig;
-        configs.name = packageName;
-        configs.directory = path.join(parent, 'packages');
-
-        switch ((packageConfig as any)?.type) {
-            case 'packages-core':
-                await generateCorePackage(tree, configs);
-                break;
-            case 'packages-browser':
-                await generateBrowserPackage(tree, configs);
-                break;
-            case 'packages-client':
-                await generateClientPackage(tree, configs);
-                break;
-            case 'packages-server':
-                await generateServerPackage(tree, configs);
-                break;
-            default:
-                break;
+const generateModules = async (tree: Tree, options: any) => {
+    for (const [moduleName, moduleConfig] of Object.entries(options.packages.modules)) {
+        for (const [packageName, packageConfig] of Object.entries(moduleConfig)) {
+            const configs: any = {
+                ...(packageConfig as any),
+                name: moduleName,
+                directory: path.join(options.parent, 'packages'),
+                ns: options.ns,
+                type: packageName,
+            };
+            await generatePackage(tree, configs, false);
         }
     }
 };
 
 const processConfigs = async (tree: Tree, configs: any) => {
     if (configs.servers) {
-        await generateServers(tree, configs.parent, configs.servers);
+        await generateServers(tree, configs);
     }
 
     if (configs.packages && configs.packages.modules) {
-        await generatePackages(tree, configs.parent, configs.packages.modules);
+        await generateModules(tree, configs);
+    }
+
+    if (configs.license) {
+        updatePackageJson(tree, configs.parent, { license: getValid(configs.license) });
+    }
+
+    if (configs.repository) {
+        updateRepository(tree, configs.parent, configs.repository);
     }
 };
 

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

@@ -0,0 +1,11 @@
+import { Tree } from '@nx/devkit';
+import * as path from 'path';
+
+export function updateHtmlPlugin(tree: Tree, projectRoot: string) {
+    const filePath = path.join(projectRoot, 'tools', 'html-plugin-template.ejs');
+    if (tree.exists(filePath)) {
+        const contents = tree.read(filePath).toString();
+        const newContents = contents.replace('<@', '<%').replace('@>', '%>');
+        tree.write(filePath, newContents);
+    }
+}

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

@@ -0,0 +1,23 @@
+import { Tree } from '@nx/devkit';
+import * as path from 'path';
+
+export function backupFiles(tree: Tree, projectRoot: string, files: string[]) {
+    return files.map(file => {
+        const filePath = path.join(projectRoot, file);
+        const backup: any = { file };
+        if (tree.exists(filePath)) {
+            backup.content = tree.read(filePath).toString();
+        }
+        return backup;
+    });
+}
+
+export function restoreFiles(tree: Tree, projectRoot: string, files: any[]) {
+    files.forEach((backup: any) => {
+        const filePath = path.join(projectRoot, backup.file);
+        if (backup.content) {
+            tree.write(filePath, backup.content);
+            console.log('Restored file', filePath);
+        }
+    });
+}

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

@@ -1,2 +1,6 @@
 export * from './jenkinsfileUpdate';
 export * from './packageJsonUpdate';
+export * from './lernaJsonUpdate';
+export * from './htmlPluginUpdate';
+export * from './licenseUpdate';
+export * from './ignoreUpdate';

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

@@ -1,7 +1,9 @@
+import { Tree } from '@nx/devkit';
 import fs from 'fs';
 import * as path from 'path';
 
-export function updateJenkinsFile(filePath: string, name: string) {
+export function updateJenkinsFile(tree: Tree, projectRoot: string, name: string) {
+    const filePath = path.join(projectRoot, 'Jenkinsfile');
     const paramsToUpdate = {
         BASE_NAMESPACE: name,
         CONNECTION_ID: name,
@@ -10,8 +12,8 @@ export function updateJenkinsFile(filePath: string, name: string) {
     };
 
     let jenkinsFileContent = '';
-    if (fs.existsSync(filePath)) {
-        jenkinsFileContent = fs.readFileSync(filePath, 'utf-8');
+    if (tree.exists(filePath)) {
+        jenkinsFileContent = tree.read(filePath).toString();
     }
 
     let labelExists = false;
@@ -42,6 +44,6 @@ export function updateJenkinsFile(filePath: string, name: string) {
 
     // Only write back to the file if we have made changes
     if (!labelExists || Object.keys(paramsToUpdate).some(param => !updatedContent.includes(`string(name: '${param}'`))) {
-        fs.writeFileSync(filePath, updatedContent, 'utf-8');
+        tree.write(filePath, updatedContent);
     }
 }

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

@@ -0,0 +1,53 @@
+import { Tree, updateJson } from '@nx/devkit';
+import * as path from 'path';
+import * as fs from 'fs';
+import { get, set } from 'lodash';
+
+const params = ['version', 'command:publish:allowBranch', 'command:version:allowBranch', 'packages'];
+
+export function backupLernaJson(tree: Tree, projectRoot: string) {
+    const lernaJsonPath = path.join(projectRoot, 'lerna.json');
+
+    if (tree.exists(lernaJsonPath)) {
+        const lernaJson = JSON.parse(tree.read(lernaJsonPath).toString());
+        const backup = {};
+        let exists = false;
+        for (const param of params) {
+            if (param.includes(':')) {
+                const paramValue = get(lernaJson, param.split(':'));
+                if (paramValue) {
+                    backup[param] = paramValue;
+                    exists = true;
+                }
+            } else {
+                if (lernaJson[param]) {
+                    backup[param] = lernaJson[param];
+                    exists = true;
+                }
+            }
+        }
+
+        if (exists) {
+            return backup;
+        }
+    }
+
+    return null;
+}
+
+export function restoreLernaJson(tree: Tree, projectRoot: string, backup: any) {
+    const lernaJsonPath = path.join(projectRoot, 'lerna.json');
+    if (backup && fs.existsSync(lernaJsonPath)) {
+        updateJson(tree, lernaJsonPath, (lernaJson: any) => {
+            Object.keys(backup).forEach(param => {
+                if (param.includes(':')) {
+                    lernaJson = set(lernaJson, param.split(':'), backup[param]);
+                } else {
+                    lernaJson[param] = backup[param];
+                }
+            });
+            return lernaJson;
+        });
+        console.log('Restored old values in lerna.json');
+    }
+}

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,16 +25,15 @@
         "watch": "npm run start:dev"
     },
     "dependencies": {
-        "@common-stack/client-core": "5.0.6-alpha.3",
-        "@common-stack/core": "5.0.6-alpha.3",
-        "@common-stack/server-core": "6.0.6-alpha.0",
-        "@common-stack/server-stack": "6.0.6-alpha.0",
-        "@common-stack/store-mongo": "5.0.6-alpha.3",
+        "@common-stack/client-core": "6.0.6-alpha.91",
+        "@common-stack/core": "6.0.6-alpha.91",
+        "@common-stack/server-core": "6.0.6-alpha.91",
+        "@common-stack/server-stack": "6.0.6-alpha.98",
+        "@common-stack/store-mongo": "6.0.6-alpha.93",
         "@container-stack/mailing-api": "5.2.1-alpha.1",
         "helmet": "^3.21.2",
         "react": "18.2.0",
-        "rxjs": "^6.5.3",
-        "rxjs-compat": "^6.5.3"
+        "rxjs": "^7.8.1"
     },
     "devDependencies": {
         "cross-env": "^7.0.3",

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';