@vida-global/release 1.0.0

package/README.md

@@ -0,0 +1,66 @@
+# Configuration
+Add the following scripts to your package.json
+```
+"release": "node node_modules/@vida-global/release/scripts/release.js",
+"develop": "node node_modules/@vida-global/release/scripts/release.js develop"
+```
+
+
+# Release Management
+The release script provides serves two purposes, version management and production release management.
+
+## Version Management
+```
+npm run release increment <major,minor,point>
+```
+Running this command will find the current `main` or `master` branch on your remote repo,
+search for the highest remote version, create a new release branch with the incremented version,
+and update the version in `package.json`
+
+## Production Release Management
+```
+npm run release production [version]
+```
+Running this command will find the current highest version on the remote repo, or the one specified
+by the version option, and replace `release/production` with that branch.
+
+## Example
+Given a current highest version of `release/1.5.3`
+
+#### Increment point version
+```
+npm run release increment point
+```
+This will create a new branch of `origin/master` named `release/1.6.0` and will update `package.json`
+to use `1.6.0` as the "version."
+
+#### Release
+```
+npm run release production
+```
+This will replace `release/production` with a branch of `release/1.6.0`
+
+#### Rollback a release
+```
+npm run release production
+```
+This will replace `release/production` with a branch of `release/1.6.0`
+
+
+# Development
+```
+npm run develop -- this is my new branch -i123
+```
+This will offer to create a new branch `feature/123/<YOUR_INITIALS>/this-is-my-new-branch`
+
+## Options
+#### -i --issue (required)
+Provide the issue number this branch is associated with
+
+#### -t --type (optional)
+By default, the script creates a branch of type `feature`. Using the `-t` option, you can create a
+branch of type `bugfix`, `chore`, `feature`, `hotfix`, or `refactor`
+
+#### -s --source (optional)
+By default, this script creates a branch of `origin/master`. By specifying the `-s` option and
+providing a branch name, you will create a branch from the provided source.

package/lib/release/develop.js

@@ -0,0 +1,27 @@
+const Git   = require('./git');
+const utils = require('./utils');
+
+
+async function develop(branchType, issueNumber, description, sourceBranch) {
+    const initials          = devInitials();
+    const parsedDescription = description.replace(/\s+/g, '-').toLowerCase().replace(/[^a-z0-9-]/g, '');;
+
+    const branchName = `${branchType}/${issueNumber}/${initials}/${parsedDescription}`;
+
+    const question = `Do you want to create branch ${branchName}?`;
+    const _confirm = await utils.confirmContinue(question);
+    if (!_confirm) return;
+
+    Git.createBranch(branchName, sourceBranch);
+}
+
+
+function devInitials() {
+    const name = Git.getCurrentUser()
+    return name.split(' ').map(piece => piece[0]).join('').toLowerCase();
+}
+
+
+module.exports = {
+    develop
+}

package/lib/release/git.js

@@ -0,0 +1,86 @@
+const { execSync } = require('child_process');
+
+
+function createBranch(branchName, branchToCopy=null) {
+    if (!branchToCopy) branchToCopy = getPrimaryBranch();
+
+    executeShellCommand(`git branch ${branchName} ${branchToCopy}`);
+    checkout(branchName)
+}
+
+
+function getPrimaryBranch() {
+    const allBranches = branches();
+    if (allBranches.includes('origin/master')) return 'origin/master';
+    if (allBranches.includes('origin/main'))   return 'origin/main';
+}
+
+
+function checkout(branchName) {
+    executeShellCommand(`git checkout ${branchName}`);
+}
+
+
+function pull() {
+    executeShellCommand('git pull --prune');
+}
+
+
+function push() {
+    const currBranch = getCurrentBranch();
+    executeShellCommand(`git push -u origin ${currBranch}`);
+}
+
+
+function getCurrentBranch() {
+    const allBranches = branches(false);
+    return allBranches.find(b => /^\s*\*\s+/.test(b)).replace('*', '').trim();
+}
+
+
+function forceRemotePush(sourceBranch, destBranch) {
+    executeShellCommand(`git push origin origin/${sourceBranch}:${destBranch} --force`);
+}
+
+
+function add(file) {
+    executeShellCommand(`git add ${file}`);
+}
+
+
+function commit(msg) {
+    executeShellCommand(`git commit -m '${msg}'`);
+}
+
+
+function branches(remote=true) {
+    let cmd = 'git branch';
+    if (remote) cmd = `${cmd} -r`;
+    const branches = executeShellCommand(cmd);
+    return branches.toString().split("\n").map(b => b.trim());
+}
+
+
+function getCurrentUser() {
+    return executeShellCommand(`git config user.name`).toString();
+}
+
+
+function executeShellCommand(command) {
+    return execSync(command);
+}
+
+
+module.exports = {
+    add,
+    branches,
+    checkout,
+    commit,
+    createBranch,
+    forceRemotePush,
+    getCurrentBranch,
+    getCurrentUser,
+    getPrimaryBranch,
+    pull,
+    push
+};

package/lib/release/increment.js

@@ -0,0 +1,56 @@
+const fs    = require('fs');
+const Git   = require('./git');
+const utils = require('./utils');
+
+
+const packageJsonPath = `${process.cwd()}/package.json`;
+
+
+async function increment(type) {
+    Git.pull();
+    const currVersion = utils.getCurrentVersion();
+    const newVersion  = getNewVersion(currVersion, type);
+
+    const _confirm = await utils.confirmContinue(`Do you want to create version ${newVersion}?`);
+    if (!_confirm) return;
+
+    Git.createBranch(`release/${newVersion}`);
+    updatePackageVersion(newVersion)
+    Git.push();
+}
+
+
+function getNewVersion(currVersion, type) {
+    const newVersion = currVersion.map(v => parseInt(v));
+    switch(type) {
+        case 'major':
+            newVersion[0] += 1;
+            newVersion[1]  = 0;
+            newVersion[2]  = 0;
+            break;
+        case 'minor':
+            newVersion[1] += 1;
+            newVersion[2]  = 0;
+            break;
+        case 'point':
+            newVersion[2] += 1;
+            break;
+        default:
+            throw new Error('Invalid increment type');
+    }
+    return newVersion.join('.');
+}
+
+
+function updatePackageVersion(newVersion) {
+    let packageJson = fs.readFileSync(packageJsonPath, {encoding: 'utf8'});
+        packageJson = packageJson.replace(/"version":\s*"\d+\.\d+\.\d+"/, `"version": "${newVersion}"`);
+    fs.writeFileSync(packageJsonPath, packageJson);
+    Git.add(packageJsonPath);
+    Git.commit(`build: incrementing build to ${newVersion}`);
+}
+
+
+module.exports = {
+  increment
+}

package/lib/release/index.js

@@ -0,0 +1,10 @@
+const { increment } = require('./increment');
+const { release }   = require('./release');
+const { develop }   = require('./develop');
+
+
+module.exports = {
+    develop,
+    increment,
+    release,
+}

package/lib/release/release.js

@@ -0,0 +1,30 @@
+const Git   = require('./git');
+const utils = require('./utils');
+
+
+async function release(env, versionToRelease=null) {
+    Git.pull();
+
+    if (versionToRelease) {
+        const branchName  = `origin/release/${versionToRelease}`;
+        const allBranches = Git.branches();
+        if (!allBranches.includes(branchName)) {
+            throw new Error(`release/${versionToRelease} does not exist`);
+        }
+    } else {
+        versionToRelease = utils.getCurrentVersion().join('.');
+    }
+
+    const question = `Do you want to release version ${versionToRelease} to ${env}?`;
+    const _confirm = await utils.confirmContinue(question);
+    if (!_confirm) return;
+    
+    const sourceBranch  = `release/${versionToRelease}`;
+    const releaseBranch = `release/${env}`;
+    Git.forceRemotePush(sourceBranch, releaseBranch);
+}
+
+
+module.exports = {
+    release
+}

package/lib/release/utils.js

@@ -0,0 +1,44 @@
+const Git = require('./git');
+
+
+function getCurrentVersion() {
+    const branches = Git.branches();
+    const releases = branches.filter(branchName => /release\/\d+\.\d+\.\d+/.test(branchName));
+    const versions = releases.map(branchName => {
+        return branchName.replace('origin/release/', '').split('.').map(n => parseInt(n));
+    });
+    
+    versions.sort((v1,v2) => {
+        if (v1[0] != v2[0]) return v2[0] - v1[0];
+        if (v1[1] != v2[1]) return v2[1] - v1[1];
+        return v2[2] - v1[2];
+    });
+
+    return versions[0] || [1,0,0];
+}
+
+
+async function confirmContinue(question) {
+    return await getInput(question, ['y','n']) == 'y';
+}
+
+
+async function getInput(question, options) {
+    const readline = require('node:readline/promises').createInterface({
+        input:  process.stdin,
+        output: process.stdout
+    });
+
+    const response = await readline.question(`${question} [${options.join(',')}] `);
+    readline.close();
+
+    if (options.includes(response)) return response;
+    return getInput(question, options);
+}
+
+
+module.exports = {
+    confirmContinue,
+    getCurrentVersion,
+    getInput,
+}

package/package.json

@@ -0,0 +1,15 @@
+{
+    "name": "@vida-global/release",
+    "version": "1.0.0",
+    "description": "Tools for releasing Vida tools",
+    "author": "",
+    "license": "ISC",
+    "main": "index.js",
+    "dependencies": {
+        "commander": "^13.1.0",
+        "pino": "^9.6.0",
+        "pino-pretty": "^13.0.0"
+    }
+}
+
+

package/scripts/release.js

@@ -0,0 +1,88 @@
+const commander = require('commander');
+const pino = require('pino');
+const Release   = require('../lib/release');
+
+
+const logger = pino({
+    transport: {
+        target: 'pino-pretty',
+        options: {
+            colorize: true,
+            ignore: 'pid,hostname',
+            translateTime: 'SYS:standard',
+            messageFormat: '{msg}',
+        }
+    }
+});
+
+
+function validateIssueNumber(val) {
+    const issueNumber = parseInt(val, 10);
+    if (isNaN(issueNumber)) {
+        throw new commander.InvalidArgumentError('Invalid issue number');
+    }
+
+    return issueNumber;
+}
+
+
+function validateProjectType(val) {
+    const types = ['bugfix', 'chore', 'feature', 'hotfix', 'refactor'];
+    if (!types.includes(val)) {
+        throw new commander.InvalidArgumentError(`must be one of: ${types.join(', ')}`);
+    }
+    return val;
+}
+
+
+function validateVersionType(val) {
+    const types = ['major', 'minor', 'point'];
+    if (!types.includes(val)) {
+        throw new commander.InvalidArgumentError(`must be one of: ${types.join(', ')}`);
+    }
+    return val;
+}
+
+
+const program = new commander.Command();
+program.name('Vida Release')
+       .description('A CLI for generating vida releases')
+       .version('1.0.0');
+
+
+program.command('increment')
+       .argument('<type>', 'version number to increment', validateVersionType)
+       .action(async (type) => {
+            try {
+                await Release.increment(type);
+            } catch(err) {
+                logger.error(err.message);
+            }
+       });
+
+
+program.command('production')
+       .argument('[version]', 'optional version release')
+       .action(async (version) => {
+            try {
+                await Release.release('production', version);
+            } catch(err) {
+                logger.error(err.message);
+            }
+       });
+
+
+program.command('develop')
+       .requiredOption('-i, --issue <issueNumber>', 'Must provide an issue number', validateIssueNumber)
+       .option('-t, --type [projectType]', 'Project type', validateProjectType, 'feature')
+       .option('-s, --source [sourceBranch]', 'Branch to copy')
+       .argument('<description...>', 'a description of your project')
+       .action(async (description, { issue, type, source }) => {
+            try {
+                await Release.develop(type, issue, description.join(' '), source);
+            } catch(err) {
+                logger.error(err.message);
+            }
+       });
+
+program.parse();