@vida-global/core 1.2.0 → 1.2.2

package/README.md

@@ -7,4 +7,3 @@ This package is intended to contain core elements used across all Vida Apps. Kee
 - [HttpClient](lib/http)
 - [Logger](lib/logger)
 - [VidaServer](lib/server)
-- [Release Scripts](lib/release)

package/lib/active_record/baseRecord.js

@@ -4,7 +4,7 @@ const { logger }                          = require('../logger');
 const { Model, Op }                       = require('sequelize');
 const   nodeUtil                          = require('util');
 const { redisClientFactory }              = require('../redis');
-const { tableize }                        = require('inflection');
+const { camelize, tableize }              = require('inflection');
 const   utils                             = require('./utils');
 
 
@@ -53,6 +53,15 @@ class BaseRecord extends Model {
 
         if (this._initialized) return;
 
+        const { schema, options } = this.initializationOptions;
+        this.init(schema, options);
+        this.initializeHooks();
+
+        this._initialized = true;
+    }
+
+
+    static get initializationOptions() {
         const schema  = getActiveRecordSchema(this._tableName, this.databaseId, this.connection.dialect);
         const options = {
             createdAt: 'created_at',
@@ -67,11 +76,23 @@ class BaseRecord extends Model {
             options.timestamps = false;
         }
 
-        this.init(schema, options);
+        this.configureOverridenAccessors(schema);
 
-        this.initializeHooks();
+        return { schema, options };
+    }
 
-        this._initialized = true;
+
+    static configureOverridenAccessors(schema) {
+        for (const [colName, colOptions] of Object.entries(schema)) {
+            const getterName = `_get${camelize(colName)}`;
+            const setterName = `_set${camelize(colName)}`;
+            if (this.prototype[getterName]) {
+                colOptions.get = this.prototype[getterName]
+            }
+            if (this.prototype[setterName]) {
+                colOptions.set = this.prototype[setterName]
+            }
+        }
     }
 
 

package/package.json

@@ -1,14 +1,14 @@
 {
     "name": "@vida-global/core",
-    "version": "1.2.0",
+    "version": "1.2.2",
     "description": "Core libraries for supporting Vida development",
     "author": "",
     "license": "ISC",
     "main": "index.js",
     "scripts": {
         "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules node_modules/jest/bin/jest.js",
-        "release": "node ./scripts/release.js",
-        "develop": "node ./scripts/release.js develop"
+        "release": "node node_modules/@vida-global/release/scripts/release.js",
+        "develop": "node node_modules/@vida-global/release/scripts/release.js develop"
     },
     "jest": {
         "collectCoverage": true,
@@ -29,7 +29,8 @@
         "response-time": "^2.3.3",
         "sequelize": "^6.37.7",
         "sequelize-cli": "^6.6.3",
-        "socket.io": "^4.4.0"
+        "socket.io": "^4.4.0",
+        "@vida-global/release": "^1.0.0"
     },
     "devDependencies": {
         "jest": "^29.6.2",

package/test/active_record/baseRecord.test.js

@@ -6,6 +6,7 @@ const   importSchema              = require('../../lib/active_record/db/importSc
 const { Model, Sequelize }        = require('sequelize');
 const { redisClientFactory }      = require('../../lib/redis');
 const   TestHelpers               = require('@vida-global/test-helpers');
+const { camelize }                = require('inflection');
 
 
 const connectionConfig = {database: ' ', host: ' ', password: ' ', username: ' '};
@@ -53,6 +54,7 @@ const dataTypeKey1   = Object.keys(Sequelize.DataTypes)[0];
 const dataTypeKey2   = Object.keys(Sequelize.DataTypes)[1];
 const dataTypeValue1 = Sequelize.DataTypes[dataTypeKey1].types.postgres[0];
 const dataTypeValue2 = Sequelize.DataTypes[dataTypeKey2].types.postgres[0];
+const col1Name       = `${TestHelpers.Faker.Text.randomString()}_${TestHelpers.Faker.Text.randomString()}_${TestHelpers.Faker.Text.randomString()}`;
 
 
 jest.mock('../../lib/redis', () => {
@@ -67,7 +69,12 @@ jest.mock('../../lib/redis', () => {
 });
 
 jest.mock('../../lib/active_record/db/importSchema', () => jest.fn());
-importSchema.mockImplementation(() => ({created_at: {type: dataTypeValue1}, updated_at: {type: dataTypeValue2}}));
+const schema = {created_at: {type: dataTypeValue1},
+                updated_at: {type: dataTypeValue2},
+                [col1Name]: {type: dataTypeValue2}
+};
+importSchema.mockImplementation(() => structuredClone(schema));
+beforeEach(() => importSchema.mockImplementation(() => structuredClone(schema)));
 
 
 afterEach(() => {
@@ -88,7 +95,8 @@ describe('BaseRecord', () => {
             class User extends BaseRecord {}
             User.initialize();
             const tableDetails = {created_at: {type: Sequelize.DataTypes[dataTypeKey1]},
-                                  updated_at: {type: Sequelize.DataTypes[dataTypeKey2]}
+                                  updated_at: {type: Sequelize.DataTypes[dataTypeKey2]},
+                                  [col1Name]: {type: Sequelize.DataTypes[dataTypeKey2]}
             };
             expect(importSchema).toHaveBeenCalledTimes(1);
             expect(Model.init).toHaveBeenCalledTimes(1);
@@ -137,6 +145,34 @@ describe('BaseRecord', () => {
         it ('will throw an error when run on BaseRecord', () => {
             expect(() => BaseRecord.initialize()).toThrow();
         });
+
+        it ('allows for overriding getters and setters', () => {
+            class User extends BaseRecord {}
+            const getterMethodName = `_get${camelize(col1Name)}`;
+            const setterMethodName = `_set${camelize(col1Name)}`;
+            const getter = jest.fn();
+            const setter = jest.fn();
+            User.prototype[getterMethodName] = getter;
+            User.prototype[setterMethodName] = setter;
+            User.initialize();
+            const tableDetails = {created_at: {type: Sequelize.DataTypes[dataTypeKey1]},
+                                  updated_at: {type: Sequelize.DataTypes[dataTypeKey2]},
+                                  [col1Name]: {
+                                      type: Sequelize.DataTypes[dataTypeKey2],
+                                      get: getter,
+                                      set: setter,
+                                  }};
+            expect(Model.init).toHaveBeenCalledWith(tableDetails,
+                                                    {
+                                                      createdAt: 'created_at',
+                                                      deletedAt: 'deleted_at',
+                                                      modelName: 'User',
+                                                      sequelize: mockSequelize,
+                                                      tableName: 'users',
+                                                      updatedAt: 'updated_at'
+                                                    });
+
+        });
     });
 
 

package/lib/release/README.md

@@ -1,66 +0,0 @@
-# Configuration
-Add the following scripts to your package.json
-```
-"release": "node node_modules/@vida-global/core/scripts/release.js",
-"develop": "node node_modules/@vida-global/core/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

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

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

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

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

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();
-    });
-});
-

package/test/release/utils.test.js

@@ -1,148 +0,0 @@
-const Git         = require('../../lib/release/git');
-const TestHelpers = require('@vida-global/test-helpers');
-const utils       = require('../../lib/release/utils');
-const readline    = require('node:readline/promises');
-
-
-jest.mock('node:readline/promises', () => {
-    return { createInterface: jest.fn(), question: jest.fn(), close: jest.fn() };
-});
-
-jest.mock('../../lib/release/git', () => {
-    return {branches: jest.fn()};
-});
-
-
-beforeEach(() => {
-    jest.resetAllMocks();
-    readline.createInterface.mockImplementation(() => {
-        return {question: readline.question, close: readline.close};
-    });
-});
-
-
-describe('getCurrentVersion', () => {
-    const major1 = TestHelpers.Faker.Math.randomNumber();
-    const minor1 = TestHelpers.Faker.Math.randomNumber();
-    const point1 = TestHelpers.Faker.Math.randomNumber();
-    const diff1  = TestHelpers.Faker.Math.randomNumber();
-    const diff2  = TestHelpers.Faker.Math.randomNumber();
-
-    const b1     = `origin/release/${major1}/${minor1}/${point1}`;
-
-    it ('sorts branches by primary version first', () => {
-        const b2 = `origin/release/${major1 + diff1        }.${minor1 + diff2}.${point1 + diff1}`;
-        const b3 = `origin/release/${major1 + diff1 + diff2}.${minor1        }.${point1}`;
-        Git.branches.mockImplementation(() => [b1, b3, b2]);
-        expect(utils.getCurrentVersion()).toEqual([major1+diff1+diff2, minor1, point1]);
-    });
-
-    it ('sorts branches by minor version second', () => {
-        const b2 = `origin/release/${major1 + diff1}.${minor1 + diff1 + diff2}.${point1}`;
-        const b3 = `origin/release/${major1 + diff1}.${minor1 + diff1        }.${point1 + diff1}`;
-        Git.branches.mockImplementation(() => [b1, b3, b2]);
-        expect(utils.getCurrentVersion()).toEqual([major1+diff1, minor1+diff1+diff2, point1]);
-    });
-
-    it ('sorts branches by point version last', () => {
-        const b2 = `origin/release/${major1 + diff1}.${minor1 + diff1}.${point1 + diff1}`;
-        const b3 = `origin/release/${major1 + diff1}.${minor1 + diff1}.${point1 + diff1 + diff2}`;
-        Git.branches.mockImplementation(() => [b1, b3, b2]);
-        expect(utils.getCurrentVersion()).toEqual([major1+diff1, minor1+diff1, point1+diff1+diff2]);
-    });
-
-    it ('ignores branches that don not fit the pattern', () => {
-        const b2 = `origin/release/${major1 + diff1}.${minor1}.${point1}`;
-        const b3 = `origin/release/${TestHelpers.Faker.Text.randomString()}`;
-        const b4 = TestHelpers.Faker.Text.randomString();
-        Git.branches.mockImplementation(() => [b1, b3, b2, b4]);
-        expect(utils.getCurrentVersion()).toEqual([major1+diff1, minor1, point1]);
-    });
-
-    it ('defaults to 1.0.0', () => {
-        const b2 = `origin/release/${TestHelpers.Faker.Text.randomString()}`;
-        const b3 = `origin/release/${TestHelpers.Faker.Text.randomString()}`;
-        const b4 = TestHelpers.Faker.Text.randomString();
-        Git.branches.mockImplementation(() => [b3, b2, b4]);
-        expect(utils.getCurrentVersion()).toEqual([1, 0, 0]);
-    });
-});
-
-
-describe('getInput', () => {
-    let question;
-    let numOptions;
-    let options;
-    let answer;
-    beforeEach(() => {
-        question   = TestHelpers.Faker.Text.randomSentence();
-        numOptions = TestHelpers.Faker.Math.randomNumber(10);
-        options    = [...Array(numOptions)].map(() => TestHelpers.Faker.Text.randomString());
-        answer     = options[Math.floor(Math.random() * numOptions)];
-        readline.question.mockImplementation(() => answer);
-    });
-
-    it ('asks the question and appends the options', async () => {
-        await utils.getInput(question, options)
-        expect(readline.question).toHaveBeenCalledWith(`${question} [${options.join(',')}] `);
-    });
-
-    it ('asks the question once if it gets a valid answer', async () => {
-        const theAnswer = await utils.getInput(question, options)
-        expect(readline.question).toHaveBeenCalledTimes(1);
-        expect(theAnswer).toEqual(answer);
-    });
-
-    it ('closes the input after getting an answer', async () => {
-        await utils.getInput(question, options)
-        expect(readline.question).toHaveBeenCalledTimes(1);
-        expect(readline.close).toHaveBeenCalledTimes(1);
-        expect(readline.question).toHaveBeenCalledBefore(readline.close);
-    });
-
-    it ('repeats the question until it gets a valid answer', async () => {
-        const numAttempts   = TestHelpers.Faker.Math.randomNumber(10);
-        let   attemptNumber = 1;
-
-        readline.question.mockImplementation(() => {
-            if (attemptNumber == numAttempts) return answer;
-            attemptNumber = attemptNumber + 1;
-            return TestHelpers.Faker.Text.randomString();
-        });
-
-        const theAnswer = await utils.getInput(question, options)
-        expect(readline.question).toHaveBeenCalledTimes(numAttempts);
-        expect(readline.close).toHaveBeenCalledTimes(numAttempts);
-        expect(theAnswer).toEqual(answer);
-
-        for(let i=1; i <= numAttempts; i++){
-            expect(readline.question).toHaveBeenNthCalledWith(i, `${question} [${options.join(',')}] `);
-        }
-    });
-});
-
-
-describe('confirmContinue', () => {
-    let question;
-    beforeEach(() => {
-        question = TestHelpers.Faker.Text.randomSentence();
-    });
-
-    it ('asks the question with "y" or "n" as options', async () => {
-        readline.question.mockImplementation(() => 'y');
-        await utils.confirmContinue(question);
-        expect(readline.question).toHaveBeenCalledWith(`${question} [y,n] `);
-    });
-
-    it ('returns true if the user answers "y"', async () => {
-        readline.question.mockImplementation(() => 'y');
-        const confirmed = await utils.confirmContinue(question);
-        expect(confirmed).toBeTruthy();
-    });
-
-    it ('returns false if the user answers "n"', async () => {
-        readline.question.mockImplementation(() => 'n');
-        const confirmed = await utils.confirmContinue(question);
-        expect(confirmed).toBeFalsy();
-    });
-});