@common-stack/generate-plugin 5.0.5-alpha.9 → 6.0.1-alpha.0

package/lib/generators/add-fullstack/files/rollup.config.base.mjs

@@ -0,0 +1,147 @@
+// rollup.config.base.js
+import graphql from '@rollup/plugin-graphql';
+import image from '@rollup/plugin-image';
+import typescript from '@rollup/plugin-typescript';
+import { string } from 'rollup-plugin-string';
+import { copy } from '@web/rollup-plugin-copy';
+import modifyLibFilesPlugin from '@common-stack/rollup-vite-utils/lib/rollup/rollupPluginModifyLibFiles.js';
+import generateJsonFromObject from '@common-stack/rollup-vite-utils/lib/rollup/rollupPluginGenerateJson.js';
+import addJsExtensionToImportsPlugin from '@common-stack/rollup-vite-utils/lib/rollup/rollupPluginAddJsExtension.js';
+// Define any additional plugins specific to this bundle
+const additionalPlugins = [copy({ patterns: '**/cdm-locales/**/*', rootDir: './src' })];
+
+function deepMergeConfigs(baseConfig, specificConfig) {
+    const mergedConfig = { ...baseConfig, ...specificConfig };
+
+    // Assuming both configs have a plugins array; adjust logic as needed
+    if (baseConfig.plugins && specificConfig.plugins) {
+        mergedConfig.plugins = [...baseConfig.plugins, ...specificConfig.plugins];
+    }
+
+    return mergedConfig;
+}
+
+// Base configuration
+const baseConfig = {
+    plugins: [
+        image(),
+        graphql({ include: '**/*.gql' }),
+        string({
+            include: ['**/*.ejs', '**/*.graphql'],
+        }),
+        addJsExtensionToImportsPlugin({
+            packages: '*',
+            needToAddIndexJs: [],
+            excludeImports: ['@emotion/react/jsx-runtime'],
+        }),
+        typescript(), // TypeScript at the top as per best practices
+        modifyLibFilesPlugin({
+            include: ['**/**/compute.js'], // Adjust to target specific files or patterns
+            outputDir: 'lib', // Ensure this matches your actual output directory
+        }),
+        generateJsonFromObject({}),
+        ...additionalPlugins,
+    ],
+    external: (id) => !/^[./]/.test(id),
+    globals: { react: 'React' },
+};
+
+// Function to create a configuration by extending the base
+function createRollupConfig(overrides) {
+    return deepMergeConfigs(baseConfig, overrides);
+}
+function watch(watchOptions, buildMode = '') {
+    const filename = path.basename(watchOptions.input);
+    message(
+        'note',
+        `${dt()} Rollup: Watcher Starting - watching for changes starting with: "${filename}" buildMode="${buildMode}"...`,
+        'WATCH  ',
+        true,
+    );
+    const watcher = rollup.watch(watchOptions);
+
+    watcher.on('event', (event) => {
+        // event.code can be one of:
+        //   START        — the watcher is (re)starting
+        //   BUNDLE_START — building an individual bundle
+        //                  * event.input will be the input options object if present
+        //                  * event.output contains an array of the "file" or
+        //                    "dir" option values of the generated outputs
+        //   BUNDLE_END   — finished building a bundle
+        //                  * event.input will be the input options object if present
+        //                  * event.output contains an array of the "file" or
+        //                    "dir" option values of the generated outputs
+        //                  * event.duration is the build duration in milliseconds
+        //                  * event.result contains the bundle object that can be
+        //                    used to generate additional outputs by calling
+        //                    bundle.generate or bundle.write. This is especially
+        //                    important when the watch.skipWrite option is used.
+        //                  You should call "event.result.close()" once you are done
+        //                  generating outputs, or if you do not generate outputs.
+        //                  This will allow plugins to clean up resources via the
+        //                  "closeBundle" hook.
+        //   END          — finished building all bundles
+        //   ERROR        — encountered an error while bundling
+        //                  * event.error contains the error that was thrown
+        //                  * event.result is null for build errors and contains the
+        //                    bundle object for output generation errors. As with
+        //                    "BUNDLE_END", you should call "event.result.close()" if
+        //                    present once you are done.
+        // If you return a Promise from your event handler, Rollup will wait until the
+        // Promise is resolved before continuing.
+        // console.log(`rollup: ${event.code}`)
+        if (event.code === 'BUNDLE_END') {
+            const outputFiles = event.output.map((o) => path.basename(o)).join(', .../');
+            const msg = `${dt()} Rollup: wrote bundle${event.output.length > 1 ? 's' : ''}: ".../${outputFiles}"`;
+            if (NOTIFY) {
+                notifier.notify({
+                    title: 'React Component Build',
+                    message: msg,
+                });
+            }
+            // messenger: success, warn, critical, note, log
+            message('success', msg, 'SUCCESS', true);
+        } else if (event.code === 'ERROR') {
+            message('critical', `!!!!!!!!!!!!!!!\nRollup ${event.error}\n!!!!!!!!!!!!!!!\n`, 'ERROR', true);
+            if (NOTIFY) {
+                notifier.notify({
+                    title: 'NotePlan Plugins Build',
+                    message: `An error occurred during build process.\nSee console for more information`,
+                });
+            }
+        }
+    });
+
+    // This will make sure that bundles are properly closed after each run
+    watcher.on('event', ({ result }) => {
+        if (result) {
+            result.close();
+        }
+    });
+
+    // Additionally, you can hook into the following. Again, return a Promise to
+    // make Rollup wait at that stage:
+    watcher.on('change', (id /* , { event } */) => {
+        const filename = path.basename(id);
+        message('info', `${dt()} Rollup: file: "${filename}" changed`, 'CHANGE', true);
+        /* a file was modified */
+    });
+    watcher.on('restart', () => {
+        // console.log(`rollup: restarting`)
+        /* a new run was triggered (usually a watched file change) */
+    });
+    watcher.on('close', () => {
+        console.log(`rollup: closing`);
+        /* the watcher was closed, see below */
+    });
+    process.on('SIGINT', async function () {
+        console.log('\n\n');
+        console.log(colors.yellow('Quitting...\n'));
+        if (watcher) {
+            await watcher.close();
+        }
+        process.exit();
+    });
+}
+
+export { createRollupConfig, baseConfig };

package/lib/generators/add-fullstack/files/tools/.eslintrc

@@ -0,0 +1,5 @@
+{
+    "rules": {
+        "import/no-extraneous-dependencies": 0
+    }
+}

package/lib/generators/add-fullstack/files/tools/cli/command-invoker.js

@@ -0,0 +1,54 @@
+const { MODULE_TEMPLATES } = require('./config');
+
+/**
+ * Class CommandInvoker. Takes all CLI operations and calls certain CLI operation depends of variables.
+ */
+class CommandInvoker {
+    /**
+     * Sets CLI operations (functions).
+     * @constructor
+     *
+     * @param addModule - The function for creating a new module.
+     * @param deleteModule - The function for deleting existing module.
+     */
+    constructor(addModule, deleteModule) {
+        this.addModule = addModule;
+        this.deleteModule = deleteModule;
+    }
+
+    /**
+     * Calls CLI operation with correct location.
+     *
+     * @param func - The func to call.
+     * @param location - The location for a new module [browser|server|both].
+     * @param args - The function for deleting existing module.
+     */
+    static runCommand(func, location, ...args) {
+        // browser
+        if (location === 'browser' || location === 'both') {
+            func(...args, 'browser');
+        }
+        // server
+        if (location === 'server' || location === 'both') {
+            func(...args, 'server');
+        }
+    }
+
+    /**
+     * Runs operation (function) for creating a new module.
+     */
+    runAddModule(args, options, logger) {
+        const { moduleName, location = 'both' } = args;
+        CommandInvoker.runCommand(this.addModule, location, logger, MODULE_TEMPLATES, moduleName);
+    }
+
+    /**
+     * Runs operation (function) for deleting existing module.
+     */
+    runDeleteModule(args, options, logger) {
+        const { moduleName, location = 'both' } = args;
+        CommandInvoker.runCommand(this.deleteModule, location, logger, moduleName);
+    }
+}
+
+module.exports = CommandInvoker;

package/lib/generators/add-fullstack/files/tools/cli/commands/add-module.js

@@ -0,0 +1,64 @@
+const shell = require('shelljs');
+const fs = require('fs');
+const chalk = require('chalk');
+const { copyFiles, renameFiles, computeModulesPath, runPrettier } = require('../helpers/util');
+
+/**
+ * Adds application module to browser or server code and adds it to the module list.
+ *
+ * @param logger - The Logger.
+ * @param templatesPath - The path to the templates for a new module.
+ * @param moduleName - The name of a new module.
+ * @param location - The location for a new module [browser|server|both].
+ * @param finished - The flag about the end of the generating process.
+ */
+function addModule(logger, templatesPath, moduleName, location, finished = true) {
+    logger.info(`Copying ${location} files…`);
+
+    // create new module directory
+    const destinationPath = computeModulesPath(location, moduleName);
+    const newModule = shell.mkdir(destinationPath);
+
+    // continue only if directory does not jet exist
+    if (newModule.code !== 0) {
+        console.log(newModule)
+        logger.error(`creating destination '${destinationPath} failed.`)
+        logger.error(chalk.red(`The ${moduleName} directory is already exists.`));
+        process.exit();
+    }
+    //copy and rename templates in destination directory
+    copyFiles(destinationPath, templatesPath, location);
+    renameFiles(destinationPath, moduleName);
+
+    logger.info(chalk.green(`✔ The ${location} files have been copied!`));
+
+    // get index file path
+    const modulesPath = computeModulesPath(location);
+    const indexFullFileName = fs.readdirSync(modulesPath).find(name => name.search(/index/) >= 0);
+    const indexPath = modulesPath + indexFullFileName;
+    let indexContent;
+
+    try {
+        // prepend import module
+        indexContent = `import ${moduleName} from './${moduleName}';\n` + fs.readFileSync(indexPath);
+    } catch (e) {
+        logger.error(chalk.red(`Failed to read ${indexPath} file`));
+        process.exit();
+    }
+
+    // extract application modules
+    const appModuleRegExp = /Module\(([^()]+)\)/g;
+    const [, appModules] = appModuleRegExp.exec(indexContent) || ['', ''];
+
+    // add module to app module list
+    shell
+        .ShellString(indexContent.replace(RegExp(appModuleRegExp, 'g'), `Module(${moduleName}, ${appModules})`))
+        .to(indexPath);
+    runPrettier(indexPath);
+
+    if (finished) {
+        logger.info(chalk.green(`✔ Module for ${location} successfully created!`));
+    }
+}
+
+module.exports = addModule;

package/lib/generators/add-fullstack/files/tools/cli/commands/delete-module.js

@@ -0,0 +1,56 @@
+const shell = require('shelljs');
+const fs = require('fs');
+const chalk = require('chalk');
+const { computeModulesPath, runPrettier } = require('../helpers/util');
+
+/**
+ * Removes the module from browser, server or both locations and removes the module from the module list.
+ *
+ * @param logger - The Logger.
+ * @param moduleName - The name of a new module.
+ * @param location - The location for a new module [browser|server|both].
+ */
+function deleteModule(logger, moduleName, location) {
+    logger.info(`Deleting ${location} files…`);
+    const modulePath = computeModulesPath(location, moduleName);
+
+    if (fs.existsSync(modulePath)) {
+        // remove module directory
+        shell.rm('-rf', modulePath);
+
+        const modulesPath = computeModulesPath(location);
+
+        // get index file path
+        const indexFullFileName = fs.readdirSync(modulesPath).find(name => name.search(/index/) >= 0);
+        const indexPath = modulesPath + indexFullFileName;
+        let indexContent;
+
+        try {
+            indexContent = fs.readFileSync(indexPath);
+        } catch (e) {
+            logger.error(chalk.red(`Failed to read ${indexPath} file`));
+            process.exit();
+        }
+
+        // extract application modules
+        const appModuleRegExp = /Module\(([^()]+)\)/g;
+        const [, appModules] = appModuleRegExp.exec(indexContent) || ['', ''];
+        const appModulesWithoutDeleted = appModules.split(',').filter(appModule => appModule.trim() !== moduleName);
+
+        const contentWithoutDeletedModule = indexContent
+            .toString()
+            // remove module from modules list
+            .replace(appModuleRegExp, `Module(${appModulesWithoutDeleted.toString().trim()})`)
+            // remove module import
+            .replace(RegExp(`import ${moduleName} from './${moduleName}';\n`, 'g'), '');
+
+        fs.writeFileSync(indexPath, contentWithoutDeletedModule);
+        runPrettier(indexPath);
+
+        logger.info(chalk.green(`✔ Module for ${location} successfully deleted!`));
+    } else {
+        logger.info(chalk.red(`✘ Module ${location} location for ${modulePath} not found!`));
+    }
+}
+
+module.exports = deleteModule;

package/lib/generators/add-fullstack/files/tools/cli/config.js

@@ -0,0 +1,11 @@
+const path = require('path');
+
+const BASE_PATH = path.resolve(`${__dirname}/../..`);
+const TEMPLATES_DIR = `${BASE_PATH}/tools/templates`;
+const MODULE_TEMPLATES = `${TEMPLATES_DIR}/module`;
+
+module.exports = {
+    BASE_PATH,
+    TEMPLATES_DIR,
+    MODULE_TEMPLATES
+};

package/lib/generators/add-fullstack/files/tools/cli/helpers/util.js

@@ -0,0 +1,76 @@
+const shell = require('shelljs');
+const fs = require('fs');
+const { pascalize, decamelize } = require('humps');
+const { startCase } = require('lodash');
+const { BASE_PATH } = require('../config');
+
+/**
+ * Copies the templates to the destination directory.
+ *
+ * @param destinationPath - The destination path for a new module.
+ * @param templatesPath - The path to the templates for a new module.
+ * @param location - The location for a new module [client|server|both].
+ */
+function copyFiles(destinationPath, templatesPath, location) {
+    shell.cp('-R', `${templatesPath}/${location}/*`, destinationPath);
+}
+
+/**
+ * Renames the templates in the destination directory.
+ *
+ * @param destinationPath - The destination path of a new module.
+ * @param moduleName - The name of a new module.
+ */
+function renameFiles(destinationPath, moduleName) {
+    const Module = pascalize(moduleName);
+
+    // change to destination directory
+    shell.cd(destinationPath);
+
+    // rename files
+    shell.ls('-Rl', '.').forEach(entry => {
+        if (entry.isFile()) {
+            shell.mv(entry.name, entry.name.replace('Module', Module));
+        }
+    });
+
+    // replace module names
+    shell.ls('-Rl', '.').forEach(entry => {
+        if (entry.isFile()) {
+            shell.sed('-i', /\$module\$/g, moduleName, entry.name);
+            shell.sed('-i', /\$_module\$/g, decamelize(moduleName), entry.name);
+            shell.sed('-i', /\$Module\$/g, Module, entry.name);
+            shell.sed('-i', /\$MoDuLe\$/g, startCase(moduleName), entry.name);
+            shell.sed('-i', /\$MODULE\$/g, moduleName.toUpperCase(), entry.name);
+        }
+    });
+}
+
+/**
+ * Gets the computed path of the module or modules dir path.
+ *
+ * @param location - The location for a new module [client|server|both].
+ * @param moduleName - The name of a new module.
+ * @returns {string} - Return the computed path
+ */
+function computeModulesPath(location, moduleName = '') {
+    return `${BASE_PATH}/packages-modules/${moduleName}/${location}`;
+}
+
+/**
+ * Run prettier on file that was changed.
+ *
+ * @param pathToFile
+ */
+function runPrettier(pathToFile) {
+    if (fs.existsSync(pathToFile)) {
+        shell.exec(`prettier --print-width 120 --single-quote --loglevel error --write ${pathToFile}`);
+    }
+}
+
+module.exports = {
+    renameFiles,
+    copyFiles,
+    computeModulesPath,
+    runPrettier
+};

package/lib/generators/add-fullstack/files/tools/cli.js

@@ -0,0 +1,31 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+// require('babel-register')({ presets: ['env'], plugins: ['transform-class-properties'] });
+// require('babel-polyfill');
+const prog = require('caporal');
+
+const addModuleCommand = require('./cli/commands/add-module');
+const deleteModuleCommand = require('./cli/commands/delete-module');
+const CommandInvoker = require('./cli/command-invoker');
+
+const commandInvoker = new CommandInvoker(addModuleCommand, deleteModuleCommand);
+
+prog
+  .version('1.0.0')
+  .description('Full info: https://github.com/sysgears/apollo-universal-starter-kit/wiki/Apollo-Starter-Kit-CLI')
+  // Add module
+  .command('addmodule', 'Create a new Module.')
+  .argument('<moduleName>', 'Module name')
+  .argument(
+    '[location]',
+    'Where should new module be created. [both, server, browser]',
+    ['both', 'server', 'browser'],
+    'both',
+  )
+  .action((args, options, logger) => commandInvoker.runAddModule(args, options, logger))
+  // Delete module
+  .command('deletemodule', 'Delete a Module')
+  .argument('<moduleName>', 'Module name')
+  .argument('[location]', 'Where should we delete module. [both, server, browser]', ['both', 'server', 'browser'], 'both')
+  .action((args, options, logger) => commandInvoker.runDeleteModule(args, options, logger));
+
+prog.parse(process.argv);

package/lib/generators/add-fullstack/files/tools/deploy-cli/runUpdateJenkinsfileVersion.js

@@ -0,0 +1,30 @@
+const { exec } = require('child_process');
+const path = require('path');
+
+// Use __dirname to get the directory of the current script and specify the relative path to the Jenkinsfile
+const jenkinsfilePath = path.join(__dirname, '../../Jenkinsfile'); // Replace with your actual Jenkinsfile relative path
+
+// Function to run the update script
+function runUpdateScript(versionArg) {
+    exec(`node ${path.join(__dirname, 'updateJenkinsfileVersion.js')} ${jenkinsfilePath} ${versionArg}`, (error, stdout, stderr) => {
+        if (error) {
+            console.error(`Error: ${error.message}`);
+            return;
+        }
+        if (stderr) {
+            console.error(`Stderr: ${stderr}`);
+            return;
+        }
+        console.log(`Stdout: ${stdout}`);
+    });
+}
+
+// Process command line arguments
+const versionArg = process.argv[2];
+
+if (!versionArg || !versionArg.match(/^v\d+(\.\d+)?$/)) {
+    console.error('Usage: node runUpdateJenkinsfileVersion.js v[Major].[Minor]');
+    process.exit(1);
+}
+
+runUpdateScript(versionArg);

package/lib/generators/add-fullstack/files/tools/deploy-cli/runUpdateVersionWrapper.js

@@ -0,0 +1,32 @@
+const { exec } = require('child_process');
+const path = require('path');
+
+// Define the path to lerna.json relative to the tools directory
+const LERNA_JSON_PATH = path.join(__dirname, '../../lerna.json'); // Update this to the actual relative path of your lerna.json file
+
+function runUpdateVersion(versionArg) {
+    const scriptPath = path.join(__dirname, 'updateLernaVersion.js');
+
+    exec(`node ${scriptPath} ${LERNA_JSON_PATH} ${versionArg}`, (err, stdout, stderr) => {
+        if (err) {
+            console.error(`Execution error: ${err}`);
+            return;
+        }
+
+        if (stderr) {
+            console.error(`Error: ${stderr}`);
+            return;
+        }
+
+        console.log(stdout);
+    });
+}
+
+const versionArg = process.argv[2];
+
+if (!versionArg || !versionArg.match(/^v\d+(\.\d+)?$/)) {
+    console.error('Usage: node runUpdateVersionWrapper.js v[Major].[Minor]');
+    process.exit(1);
+}
+
+runUpdateVersion(versionArg);

package/lib/generators/add-fullstack/files/tools/deploy-cli/runUpdateYamlSettingsWrapper.js

@@ -0,0 +1,38 @@
+const path = require('path');
+const { exec } = require('child_process');
+
+// Define the path to lerna.json relative to the tools directory
+const DEV_YAML_SETTIGNS = path.join(__dirname, '../../values-dev.yaml');
+
+// Function to call the updateConfiguration script
+function runUpdateYamlSettings(version) {
+    // Construct the path to the updateConfiguration script
+    const updateScriptPath = path.join(__dirname, 'updateYamlSettings.js');
+
+    // Construct the command to execute
+    const command = `node ${updateScriptPath} ${DEV_YAML_SETTIGNS} ${version}`;
+
+    // Execute the command
+    exec(command, (error, stdout, stderr) => {
+        if (error) {
+            console.error(`Error: ${error.message}`);
+            return;
+        }
+        if (stderr) {
+            console.error(`Error: ${stderr}`);
+            return;
+        }
+        console.log(stdout);
+    });
+}
+
+// Process command line arguments
+const versionArg = process.argv[2];
+
+if (!versionArg || !versionArg.match(/^v\d+(\.\d+)?$/)) {
+    console.error('Usage: node runUpdateVersionWrapper.js v[Major].[Minor]');
+    process.exit(1);
+}
+
+// Call the function with the provided arguments
+runUpdateYamlSettings(versionArg);

package/lib/generators/add-fullstack/files/tools/deploy-cli/updateJenkinsfileVersion.js

@@ -0,0 +1,62 @@
+const fs = require('fs');
+
+// Function to update the Jenkinsfile
+function updateJenkinsfile(filePath, versionArg) {
+    fs.readFile(filePath, 'utf8', (err, data) => {
+        if (err) {
+            console.error(`Error reading the Jenkinsfile: ${err}`);
+            return;
+        }
+
+        // Extract the major and minor version (if present)
+        const versionParts = versionArg.match(/^v(\d+)(\.(\d+))?$/);
+        if (!versionParts) {
+            console.error('Invalid version format. Please use the format v[Major].[Minor]');
+            return;
+        }
+        const majorVersion = versionParts[1];
+        const minorVersion = versionParts[3];
+        const versionSuffix = minorVersion ? `${majorVersion}-${minorVersion}` : majorVersion;
+        // Update the branch names using correct regular expressions
+        const updatedData = data
+            .replace(
+                /string\(name: 'VERSION', defaultValue: '.*?', description: 'version of the deployment', trim: true\)/,
+                `string(name: 'VERSION', defaultValue: 'v${versionSuffix}', description: 'version of the deployment', trim: true)`
+            )
+            .replace(
+                /string\(name: 'REPOSITORY_BRANCH', defaultValue: 'develop', description: 'the branch with changes'\)/,
+                `string(name: 'REPOSITORY_BRANCH', defaultValue: 'develop${versionSuffix}', description: 'the branch with changes')`,
+            )
+            .replace(
+                /string\(name: 'DEVELOP_BRANCH', defaultValue: 'develop', description: 'the branch for the development'\)/,
+                `string(name: 'DEVELOP_BRANCH', defaultValue: 'develop${versionSuffix}', description: 'the branch for the development')`,
+            )
+            .replace(
+                /string\(name: 'PUBLISH_BRANCH', defaultValue: 'devpublish', description: 'the publish branch for packages release'\)/,
+                `string(name: 'PUBLISH_BRANCH', defaultValue: 'devpublish${versionSuffix}', description: 'the publish branch for packages release')`,
+            );
+
+        // Debugging - Log the updated lines for verification
+        console.log(updatedData.match(/(REPOSITORY_BRANCH|DEVELOP_BRANCH|PUBLISH_BRANCH).*?;/g));
+
+        // Write the updated Jenkinsfile back
+        fs.writeFile(filePath, updatedData, 'utf8', (writeErr) => {
+            if (writeErr) {
+                console.error(`Error writing the Jenkinsfile: ${writeErr}`);
+                return;
+            }
+            console.log(`Jenkinsfile updated successfully for version ${versionArg}.`);
+        });
+    });
+}
+
+// Process command line arguments
+const filePath = process.argv[2];
+const versionArg = process.argv[3];
+
+if (!filePath || !versionArg || !versionArg.match(/^v\d+(\.\d+)?$/)) {
+    console.error('Usage: node updateJenkinsfileVersion.js <path-to-Jenkinsfile> v[Major].[Minor]');
+    process.exit(1);
+}
+
+updateJenkinsfile(filePath, versionArg);

package/lib/generators/add-fullstack/files/tools/deploy-cli/updateLernaVersion.js

@@ -0,0 +1,51 @@
+const fs = require('fs');
+
+function updateLernaJson(filePath, versionArg) {
+    // Read the existing lerna.json file
+    fs.readFile(filePath, { encoding: 'utf8' }, (err, data) => {
+        if (err) {
+            console.error(`Error reading file: ${err}`);
+            return;
+        }
+
+        let lernaConfig;
+        try {
+            lernaConfig = JSON.parse(data);
+        } catch (parseErr) {
+            console.error(`Error parsing JSON: ${parseErr}`);
+            return;
+        }
+
+        // Update the version field
+        // Extract major and minor version, assuming format vMajor.Minor (e.g., v2.1)
+        const versionComponents = versionArg.substring(1).split('.');
+        const majorVersion = versionComponents[0];
+        const minorVersion = versionComponents.length > 1 ? versionComponents[1] : '0';
+        lernaConfig.version = `${majorVersion}.${minorVersion}.0`;
+
+        // Update the allowBranch fields
+        const branchName = `devpublish${majorVersion}${minorVersion !== '0' ? '.' + minorVersion : ''}`;
+        lernaConfig.command.publish.allowBranch.push(branchName);
+        lernaConfig.command.version.allowBranch.push(branchName);
+
+        // Write the updated lerna.json file
+        fs.writeFile(filePath, JSON.stringify(lernaConfig, null, 2), 'utf8', writeErr => {
+            if (writeErr) {
+                console.error(`Error writing file: ${writeErr}`);
+                return;
+            }
+            console.log(`lerna.json updated successfully to version ${lernaConfig.version} with branch ${branchName}`);
+        });
+    });
+}
+
+// Process command line arguments
+const filePath = process.argv[2];
+const versionArg = process.argv[3];
+
+if (!filePath || !versionArg || !versionArg.match(/^v\d+(\.\d+)?$/)) {
+    console.error('Usage: node updateLernaVersion.js <path-to-lerna.json> v[Major].[Minor]');
+    process.exit(1);
+}
+
+updateLernaJson(filePath, versionArg);