@vida-global/core 1.1.13 → 1.2.1

package/lib/release/release.js

@@ -1,30 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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/scripts/release.js

@@ -1,75 +0,0 @@
-const   commander = require('commander');
-const { logger }  = require('../lib/logger');
-const   Release   = require('../lib/release');
-
-
-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();

package/test/release/develop.test.js

@@ -1,57 +0,0 @@
-const { develop } = require('../../lib/release/develop');
-const   Git         = require('../../lib/release/git');
-const   TestHelpers = require('@vida-global/test-helpers');
-const   utils       = require('../../lib/release/utils');
-
-
-jest.mock('../../lib/release/git', () => {
-    return { createBranch: jest.fn(), getCurrentUser: jest.fn() }
-});
-jest.mock('../../lib/release/utils', () => {
-    return { confirmContinue: jest.fn() };
-});
-
-
-let branchType;
-let description;
-let firstName;
-let issueNumber;
-let lastName;
-let sourceBranch;
-beforeEach(() => {
-    jest.resetAllMocks();
-    utils.confirmContinue.mockImplementation(() => true);
-
-    firstName = TestHelpers.Faker.User.randomFirstName();
-    lastName  = TestHelpers.Faker.User.randomLastName();
-    Git.getCurrentUser.mockImplementation(() => `${firstName} ${lastName}`);
-
-    branchType   = TestHelpers.Faker.Text.randomString();
-    sourceBranch = TestHelpers.Faker.Text.randomString();
-    description  = TestHelpers.Faker.Text.randomSentence();
-    issueNumber  = TestHelpers.Faker.Math.randomNumber();
-});
-
-
-describe('develop', () => {
-    it ('confirms and creates a branch once', async () => {
-        await develop(branchType, issueNumber, description, sourceBranch);
-        expect(utils.confirmContinue).toHaveBeenCalledTimes(1);
-        expect(Git.createBranch).toHaveBeenCalledTimes(1);
-    });
-
-    it ('generates the correct branch name', async () => {
-        const initials   = `${firstName[0]}${lastName[0]}`.toLowerCase();
-        const branchName = `${branchType}/${issueNumber}/${initials}/${description.replace(/\s+/g, '-').toLowerCase().replace(/[^a-z0-9-]/g, '')}`;
-        await develop(branchType, issueNumber, description, sourceBranch);
-
-        expect(utils.confirmContinue).toHaveBeenCalledWith(`Do you want to create branch ${branchName}?`);
-        expect(Git.createBranch).toHaveBeenCalledWith(branchName, sourceBranch);
-    });
-
-    it ('does not create a branch if the user does not confirm', async () => {
-        utils.confirmContinue.mockImplementation(() => false);
-        await develop(branchType, issueNumber, description, sourceBranch);
-        expect(Git.createBranch).not.toHaveBeenCalled();
-    });
-});

package/test/release/git.test.js

@@ -1,189 +0,0 @@
-const { execSync }  = require('child_process');
-const   Git         = require('../../lib/release/git');
-const   TestHelpers = require('@vida-global/test-helpers');
-
-
-jest.mock('child_process', () => {
-    const execSync = jest.fn();
-    return { execSync };
-});
-
-
-beforeEach(() => {
-    jest.resetAllMocks();
-});
-
-
-describe('Git.add', () => {
-    it ('calls git add with the file name', () => {
-        const fileName = TestHelpers.Faker.Text.randomString();
-        Git.add(fileName);
-        expect(execSync).toHaveBeenCalledTimes(1);
-        expect(execSync).toHaveBeenCalledWith(`git add ${fileName}`);
-    });
-});
-
-
-describe('Git.branches', () => {
-    it ('calls git branch and returns an array of the resulting strings', () => {
-        const b1        = TestHelpers.Faker.Text.randomString();
-        const b2        = TestHelpers.Faker.Text.randomString();
-        const b3        = TestHelpers.Faker.Text.randomString();
-        const branchStr = `    ${b1}  \n    ${b2}\n${b3}    `;
-        execSync.mockImplementation(() => branchStr);
-
-        const branches = Git.branches();
-
-        expect(execSync).toHaveBeenCalledTimes(1);
-        expect(branches).toEqual([b1, b2, b3]);
-        expect(execSync).toHaveBeenCalledWith(`git branch -r`);
-    });
-
-    it ('does not include the remote option when needed', () => {
-        execSync.mockImplementation(() => '');
-        const branches = Git.branches(false);
-        expect(execSync).toHaveBeenCalledWith(`git branch`);
-    });
-});
-
-
-describe('Git.checkout', () => {
-    it ('calls git checkout with the branch name', () => {
-        const branchName = TestHelpers.Faker.Text.randomString();
-        Git.checkout(branchName);
-        expect(execSync).toHaveBeenCalledTimes(1);
-        expect(execSync).toHaveBeenCalledWith(`git checkout ${branchName}`);
-    });
-});
-
-
-describe('Git.commit', () => {
-    it ('calls git commit with comment', () => {
-        const comment = TestHelpers.Faker.Text.randomString();
-        Git.commit(comment);
-        expect(execSync).toHaveBeenCalledTimes(1);
-        expect(execSync).toHaveBeenCalledWith(`git commit -m '${comment}'`);
-    });
-});
-
-
-describe('Git.createBranch', () => {
-    it ('creates a branch and switches to it', () => {
-        const branch1 = TestHelpers.Faker.Text.randomString();
-        const branch2 = TestHelpers.Faker.Text.randomString();
-
-        Git.createBranch(branch1, branch2);
-
-        expect(execSync).toHaveBeenCalledTimes(2);
-        expect(execSync).toHaveBeenNthCalledWith(1, `git branch ${branch1} ${branch2}`);
-        expect(execSync).toHaveBeenNthCalledWith(2, `git checkout ${branch1}`);
-    });
-
-    it ('defaults to the primary branch', () => {
-        const branch1 = TestHelpers.Faker.Text.randomString();
-
-        execSync.mockImplementation(() => 'origin/main');
-
-        Git.createBranch(branch1);
-
-        expect(execSync).toHaveBeenCalledTimes(3);
-        expect(execSync).toHaveBeenNthCalledWith(2, `git branch ${branch1} origin/main`);
-    });
-});
-
-
-describe('Git.forceRemotePush', () => {
-    it ('calls git push with the origin', () => {
-        const branch1 = TestHelpers.Faker.Text.randomString();
-        const branch2 = TestHelpers.Faker.Text.randomString();
-
-        Git.forceRemotePush(branch1, branch2);
-        expect(execSync).toHaveBeenCalledTimes(1);
-        expect(execSync).toHaveBeenCalledWith(`git push origin origin/${branch1}:${branch2} --force`)
-    });
-});
-
-
-describe('Git.getCurrentUser', () => {
-    it ('returns the result of git config.name', () => {
-        const name = TestHelpers.Faker.User.randomName();
-        execSync.mockImplementation(() => name);
-
-        const response = Git.getCurrentUser();
-
-        expect(execSync).toHaveBeenCalledTimes(1);
-        expect(execSync).toHaveBeenCalledWith(`git config user.name`);
-        expect(response).toEqual(name);
-    });
-});
-
-
-describe('Git.getPrimaryBranch', () => {
-    it ('returns master when that is the primary branch', () => {
-        const branch1    = TestHelpers.Faker.Text.randomString();
-        const branch2    = TestHelpers.Faker.Text.randomString();
-        const branchStr  = `   origin/${branch1}\n  origin/master \n  origin/${branch2}`;
-        execSync.mockImplementation(() => branchStr);
-
-        const branch = Git.getPrimaryBranch();
-
-        expect(branch).toEqual('origin/master');
-    });
-
-    it ('returns main when that is the primary branch', () => {
-        const branch1    = TestHelpers.Faker.Text.randomString();
-        const branch2    = TestHelpers.Faker.Text.randomString();
-        const branchStr  = `origin/${branch1}\norigin/${branch2}\n  origin/main  `;
-        execSync.mockImplementation(() => branchStr);
-
-        const branch = Git.getPrimaryBranch();
-
-        expect(branch).toEqual('origin/main');
-    });
-
-    it ('returns undefined when it cannot determine the primary branch', () => {
-        const branch1    = TestHelpers.Faker.Text.randomString();
-        const branch2    = TestHelpers.Faker.Text.randomString();
-        const branch3    = TestHelpers.Faker.Text.randomString();
-        const branchStr  = `origin/${branch1}\norigin/${branch2}\n  origin/${branch3}  `;
-        execSync.mockImplementation(() => branchStr);
-
-        const branch = Git.getPrimaryBranch();
-
-        expect(branch).toBeUndefined();
-    });
-});
-
-
-describe('Git.getCurrentBranch', () => {
-    it ('returns the branch with the *', () => {
-        const branch1    = TestHelpers.Faker.Text.randomString();
-        const branch2    = TestHelpers.Faker.Text.randomString();
-        const branch3    = TestHelpers.Faker.Text.randomString();
-        const branchStr  = `   origin/${branch1}\n  *  ${branch3} \n  origin/${branch2}`;
-        execSync.mockImplementation(() => branchStr);
-
-        const branch = Git.getCurrentBranch();
-
-        expect(branch).toEqual(branch3);
-    });
-});
-
-
-describe('Git.pull', () => {
-    it ('calls git pull with the prune option', () => {
-        Git.pull();
-        expect(execSync).toHaveBeenCalledTimes(1);
-        expect(execSync).toHaveBeenCalledWith(`git pull --prune`);
-    });
-});
-
-
-describe('Git.push', () => {
-    it ('pushes to the current branch', () => {
-        const branch = TestHelpers.Faker.Text.randomString();
-        execSync.mockImplementation(() => `* ${branch}`);
-        Git.push();
-        expect(execSync).toHaveBeenCalledWith(`git push -u origin ${branch}`);
-    });
-});

package/test/release/increment.test.js

@@ -1,145 +0,0 @@
-const   fs          = require('fs');
-const { increment } = require('../../lib/release/increment');
-const   Git         = require('../../lib/release/git');
-const   TestHelpers = require('@vida-global/test-helpers');
-const   utils       = require('../../lib/release/utils');
-
-
-jest.mock('../../lib/release/git', () => {
-    return { add: jest.fn(), createBranch: jest.fn(), commit: jest.fn(), pull: jest.fn(), push: jest.fn() };
-});
-jest.mock('../../lib/release/utils', () => {
-    return { getCurrentVersion: jest.fn(), confirmContinue: jest.fn() };
-});
-jest.mock('fs', () => {
-    return { readFileSync: jest.fn(), writeFileSync: jest.fn() };
-});
-
-
-let   config;
-let   version;
-const packageJsonPath = `${process.cwd()}/package.json`;
-beforeEach(() => {
-    jest.resetAllMocks();
-    version = [TestHelpers.Faker.Math.randomNumber(),
-               TestHelpers.Faker.Math.randomNumber(),
-               TestHelpers.Faker.Math.randomNumber()];
-    utils.getCurrentVersion.mockImplementation(() => version);
-    utils.confirmContinue.mockImplementation(() => true);
-
-    config = {
-      [TestHelpers.Faker.Text.randomString()]: TestHelpers.Faker.Text.randomString(),
-      [TestHelpers.Faker.Text.randomString()]: TestHelpers.Faker.Text.randomString(),
-      version: version.join('.')
-    }
-    fs.readFileSync.mockImplementation(() => JSON.stringify(config, null, 4));
-});
-
-
-describe('increment', () => {
-    it ('runs steps in the proper order', async () => {
-        await increment('point');
-
-        expect(Git.pull).toHaveBeenCalledTimes(1);
-        expect(utils.getCurrentVersion).toHaveBeenCalledTimes(1);
-        expect(Git.pull).toHaveBeenCalledBefore(utils.getCurrentVersion);
-
-        expect(utils.confirmContinue).toHaveBeenCalledTimes(1);
-        expect(utils.getCurrentVersion).toHaveBeenCalledBefore(utils.confirmContinue);
-
-        expect(Git.createBranch).toHaveBeenCalledTimes(1);
-        expect(utils.confirmContinue).toHaveBeenCalledBefore(Git.createBranch);
-
-        expect(fs.readFileSync).toHaveBeenCalledTimes(1);
-        expect(Git.createBranch).toHaveBeenCalledBefore(fs.readFileSync);
-
-        expect(fs.writeFileSync).toHaveBeenCalledTimes(1);
-        expect(fs.readFileSync).toHaveBeenCalledBefore(fs.writeFileSync);
-
-        expect(Git.push).toHaveBeenCalledTimes(1);
-        expect(fs.writeFileSync).toHaveBeenCalledBefore(Git.push);
-    });
-
-
-    describe('getNewVersion', () => {
-        it ('increments the major version', async () => {
-            await increment('major');
-            const newVersion = [...version];
-            newVersion[0]    = newVersion[0] + 1;
-            newVersion[1]    = 0;
-            newVersion[2]    = 0;
-            expect(Git.createBranch).toHaveBeenCalledWith(`release/${newVersion.join('.')}`);
-        });
-
-        it ('increments the minor version', async () => {
-            await increment('minor');
-            const newVersion = [...version];
-            newVersion[1]    = newVersion[1] + 1;
-            newVersion[2]    = 0;
-            expect(Git.createBranch).toHaveBeenCalledWith(`release/${newVersion.join('.')}`);
-        });
-
-        it ('increments the point version', async () => {
-            await increment('point');
-            const newVersion = [...version];
-            newVersion[2]    = newVersion[2] + 1;
-            expect(Git.createBranch).toHaveBeenCalledWith(`release/${newVersion.join('.')}`);
-        });
-
-        it ('throws an error for an invalid type', async () => {
-            expect(async () => {await increment('foo')}).rejects.toThrow();;
-        });
-    });
-
-
-    describe('confirmation', () => {
-        it ('asks the user if they want to upgrade to the new version', async () => {
-            await increment('point');
-            const newVersion = [version[0], version[1], version[2]+1].join('.');
-            expect(utils.confirmContinue).toHaveBeenCalledWith(`Do you want to create version ${newVersion}?`);
-        });
-
-        it ('does not continue if the user responds "n"', async () => {
-            utils.confirmContinue.mockImplementation(() => false);
-            await increment('point');
-
-            expect(Git.createBranch).not.toHaveBeenCalled();
-            expect(fs.readFileSync).not.toHaveBeenCalled();
-            expect(fs.writeFileSync).not.toHaveBeenCalled();
-            expect(Git.push).not.toHaveBeenCalled();
-        });
-    });
-
-
-    describe('createBranch', () => {
-        it ('creates a release branch for the new version', async () => {
-            await increment('point');
-            const newVersion = [version[0], version[1], version[2]+1].join('.');
-            expect(Git.createBranch).toHaveBeenCalledWith(`release/${newVersion}`);
-        });
-    });
-
-
-    describe('updatePackageVersion', () => {
-        it ('writes the new package version to package.json', async () => {
-            const newVersion = [version[0], version[1], version[2]+1].join('.');
-            const newConfig  = structuredClone(config);
-            newConfig.version = newVersion;
-
-            await increment('point');
-            
-            expect(fs.writeFileSync).toHaveBeenCalledWith(packageJsonPath, JSON.stringify(newConfig, null, 4));
-        });
-
-        it ('adds package.json to be committed', async () => {
-            await increment('point');
-            expect(Git.add).toHaveBeenCalledWith(packageJsonPath);
-        });
-
-        it ('adds a descriptive commit message', async () => {
-            const newVersion = [version[0], version[1], version[2]+1].join('.');
-            await increment('point');
-            expect(Git.commit).toHaveBeenCalledWith(`build: incrementing build to ${newVersion}`);
-        });
-    });
-});

package/test/release/release.test.js

@@ -1,72 +0,0 @@
-const { release } = require('../../lib/release/release');
-const   Git         = require('../../lib/release/git');
-const   TestHelpers = require('@vida-global/test-helpers');
-const   utils       = require('../../lib/release/utils');
-
-
-jest.mock('../../lib/release/git', () => {
-    return { pull: jest.fn(), forceRemotePush: jest.fn(), branches: jest.fn() };
-});
-jest.mock('../../lib/release/utils', () => {
-    return { getCurrentVersion: jest.fn(), confirmContinue: jest.fn() };
-});
-
-
-let env;
-let version;
-beforeEach(() => {
-    jest.resetAllMocks();
-    env = TestHelpers.Faker.Text.randomString();
-    version = [TestHelpers.Faker.Math.randomNumber(),
-               TestHelpers.Faker.Math.randomNumber(),
-               TestHelpers.Faker.Math.randomNumber()];
-    utils.getCurrentVersion.mockImplementation(() => version);
-    utils.confirmContinue.mockImplementation(() => true);
-});
-
-
-describe('release', () => {
-    it ('runs steps in the proper order', async () => {
-        await release(env);
-
-        expect(Git.pull).toHaveBeenCalledTimes(1)
-        expect(utils.confirmContinue).toHaveBeenCalledTimes(1)
-        expect(Git.pull).toHaveBeenCalledBefore(utils.confirmContinue)
-
-        expect(Git.forceRemotePush).toHaveBeenCalledTimes(1)
-        expect(utils.confirmContinue).toHaveBeenCalledBefore(Git.forceRemotePush)
-    });
-
-    it ('defaults to the current version', async () => {
-        await release(env);
-        const versionStr = version.join('.');
-        expect(utils.confirmContinue).toHaveBeenCalledWith(`Do you want to release version ${versionStr} to ${env}?`);
-        expect(Git.forceRemotePush).toHaveBeenCalledWith(`release/${versionStr}`, `release/${env}`);
-    });
-    
-    it ('accepts an alternate version', async () => {
-        const altVersion = [TestHelpers.Faker.Math.randomNumber(),
-                            TestHelpers.Faker.Math.randomNumber(),
-                            TestHelpers.Faker.Math.randomNumber()].join('.');
-        Git.branches.mockImplementation(() => [`origin/release/${version.join('.')}`, `origin/release/${altVersion}`, TestHelpers.Faker.Text.randomString()]);
-        await release(env, altVersion);
-        expect(utils.confirmContinue).toHaveBeenCalledWith(`Do you want to release version ${altVersion} to ${env}?`);
-        expect(Git.forceRemotePush).toHaveBeenCalledWith(`release/${altVersion}`, `release/${env}`);
-    });
-
-    it ('does not continue if the user responds "n"', async () => {
-        utils.confirmContinue.mockImplementation(() => false);
-        await release(env);
-
-        expect(Git.forceRemotePush).not.toHaveBeenCalled();
-    });
-
-    it ('throws an error if the version does not exist', async () => {
-        const altVersion = [TestHelpers.Faker.Math.randomNumber(),
-                            TestHelpers.Faker.Math.randomNumber(),
-                            TestHelpers.Faker.Math.randomNumber()].join('.');
-        Git.branches.mockImplementation(() => [`origin/release/${version.join('.')}`, TestHelpers.Faker.Text.randomString()]);
-        expect(async () => { await release(env, altVersion)}).rejects.toThrow();
-    });
-});
-