@vida-global/core 1.1.13 → 1.2.1

package/test/active_record/baseRecord.test.js

@@ -4,6 +4,7 @@ const { ConnectionConfiguration } = require('../../lib/active_record/db/connecti
 const { getActiveRecordSchema }   = require('../../lib/active_record/db/schema');
 const   importSchema              = require('../../lib/active_record/db/importSchema');
 const { Model, Sequelize }        = require('sequelize');
+const { redisClientFactory }      = require('../../lib/redis');
 const   TestHelpers               = require('@vida-global/test-helpers');
 
 
@@ -17,12 +18,25 @@ connectionSpy.mockImplementation(() => mockSequelize);
 
 
 jest.mock('sequelize', () => {
+    const TestHelpers    = require('@vida-global/test-helpers');
     class MockModel {
-        static init     = jest.fn()
-        static findByPk = jest.fn();
-        static findAll  = jest.fn();
+        constructor(data, opts={}) {
+            this.dataValues = data || {}
+            this.options    = opts;
+            for (const [k,v] of Object.entries(this.dataValues)) {
+                this[k] = v;
+            }
+        };
+        static addHook             = jest.fn()
+        static init                = jest.fn()
+        static findByPk            = jest.fn();
+        static findAll             = jest.fn();
+        static primaryKeyAttribute = TestHelpers.Faker.Text.randomString();
+        toJSON()                   { return this.dataValues }
     }
-    const TestHelpers    = require('@vida-global/test-helpers');
+
+    MockModel.findAll.mockImplementation(() => []);
+
     const dataTypeKey1   = TestHelpers.Faker.Text.randomString();
     const dataTypeValue1 = TestHelpers.Faker.Text.randomString();
     const dataTypeKey2   = TestHelpers.Faker.Text.randomString();
@@ -41,6 +55,17 @@ const dataTypeValue1 = Sequelize.DataTypes[dataTypeKey1].types.postgres[0];
 const dataTypeValue2 = Sequelize.DataTypes[dataTypeKey2].types.postgres[0];
 
 
+jest.mock('../../lib/redis', () => {
+    const client = {
+        del:  jest.fn(),
+        mGet: jest.fn(),
+        mSet: jest.fn(),
+    }
+    const redisClientFactory = () => client;
+
+    return { redisClientFactory };
+});
+
 jest.mock('../../lib/active_record/db/importSchema', () => jest.fn());
 importSchema.mockImplementation(() => ({created_at: {type: dataTypeValue1}, updated_at: {type: dataTypeValue2}}));
 
@@ -50,16 +75,16 @@ afterEach(() => {
 });
 
 
-describe('ActiveRecord', () => {
-    describe('ActiveRecord#constructor', () => {
+describe('BaseRecord', () => {
+    describe('BaseRecord.constructor', () => {
         it ('will throw an error when creating an instance of BaseRecord', () => {
             expect(() => new BaseRecord()).toThrow();
         });
     });
 
 
-    describe('ActiveRecord.initialize', () => {
-        it ('calls `getActiveRecordSchema` and passes the response to init', () => {
+    describe('BaseRecord.initialize', () => {
+        it ('calls `getBaseRecordSchema` and passes the response to init', () => {
             class User extends BaseRecord {}
             User.initialize();
             const tableDetails = {created_at: {type: Sequelize.DataTypes[dataTypeKey1]},
@@ -115,7 +140,7 @@ describe('ActiveRecord', () => {
     });
 
 
-    describe('ActiveRecord.tableName', () => {
+    describe('BaseRecord.tableName', () => {
         it ('defaults to the puralized version of the class name', () => {
             class User extends BaseRecord {}
             expect(User._tableName).toEqual('users');
@@ -140,19 +165,30 @@ describe('ActiveRecord', () => {
     });
 
 
-    describe('ActiveRecord#find', () => {
-        it ('calls the sequelize `findByPk` method', async () => {
-            class Person extends BaseRecord {}
-            Person.initialize();
-            const id          = Math.random();
+    describe('BaseRecord.find', () => {
+        const pk = TestHelpers.Faker.Text.randomString();
+        class Person extends BaseRecord {}
+        Person.initialize();
+        Person.primaryKeyAttribute = pk;
+
+        it ('calls the sequelize `findByPk` method when passed one value', async () => {
+            const id = Math.random();
             await Person.find(id);
             expect(Person.findByPk).toHaveBeenCalledTimes(1);
             expect(Person.findByPk).toHaveBeenCalledWith(id);
         });
+
+        it ('calls the sequelize `findAll` method when passed multiple value', async () => {
+            const id1 = Math.random();
+            const id2 = Math.random();
+            await Person.find([id1, id2]);
+            expect(Person.findAll).toHaveBeenCalledTimes(1);
+            expect(Person.findAll).toHaveBeenCalledWith({where: {[pk]: [id1, id2]}});
+        });
     });
 
 
-    describe('ActiveRecord#where', () => {
+    describe('BaseRecord.where', () => {
         const column    = TestHelpers.Faker.Text.randomString();
         const value     = TestHelpers.Faker.Text.randomString();
         const condition = {[column]: value};
@@ -176,4 +212,319 @@ describe('ActiveRecord', () => {
             expect(Person.findAll).toHaveBeenCalledWith(expected);
         });
     });
+
+
+    describe('Caching', () => {
+        class Person extends BaseRecord {
+            static get isCacheable() { return true; }
+        }
+        let redisClient
+        beforeEach(async () => {
+            redisClient = await redisClientFactory();
+            redisClient.mGet.mockImplementation(keys => new Array(keys.length));
+        });
+
+        describe('BaseRecord.find', () => {
+            const findSpy = jest.spyOn(Person, '_cachedFind');
+            it ('calls _cachedFindByPk when one id is passed', async () => {
+                const id = Math.random();
+                await Person.find(id);
+                expect(Person.findByPk).toHaveBeenCalledTimes(0);
+                expect(findSpy).toHaveBeenCalledTimes(1);
+                expect(findSpy).toHaveBeenCalledWith(id);
+            });
+
+            it ('calls _cachedFind when multiple ids are passed', async () => {
+                const id1 = Math.random();
+                const id2 = Math.random();
+                await Person.find([id1, id2]);
+                expect(Person.findByPk).toHaveBeenCalledTimes(0);
+                expect(findSpy).toHaveBeenCalledTimes(1);
+                expect(findSpy).toHaveBeenCalledWith([id1, id2]);
+            });
+        });
+
+
+        describe('BaseRecord._cachedFind', () => {
+            const pk  = Person.primaryKeyAttribute;
+            const id1 = Math.random();
+            const id2 = Math.random();
+            const id3 = Math.random();
+            const id4 = Math.random();
+            
+            it ('converts ids to cache keys and fetches from cache', async () => {
+                await Person._cachedFind([id1, id2]);
+                expect(redisClient.mGet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mGet).toHaveBeenCalledWith([
+                  `Person#find:${id1}`,
+                  `Person#find:${id2}`,
+                ]);
+            });
+
+            it ('fetches misseds id from the database and caches them', async () => {
+                const key1 = `Person#find:${id1}`;
+                const key2 = `Person#find:${id2}`;
+                const key3 = `Person#find:${id3}`;
+                Person.findAll.mockImplementation(() => [new Person({[pk]:id1}), new Person({[pk]:id3})]);
+                redisClient.mGet.mockImplementation(keys => [null, '{}', null]);
+                await Person._cachedFind([id1, id2, id3]);
+
+                expect(redisClient.mGet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mGet).toHaveBeenCalledWith([key1, key2, key3]);
+                expect(Person.findAll).toHaveBeenCalledTimes(1);
+                expect(Person.findAll).toHaveBeenCalledWith({where: {[pk]: [id1, id3]}});
+                expect(redisClient.mSet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mSet).toHaveBeenCalledWith({
+                  [key1]: `AR:Person:{"${pk}":${id1}}`,
+                  [key3]: `AR:Person:{"${pk}":${id3}}`,
+                });
+            });
+
+            it ('does not hit the database for cache hits', async () => {
+                redisClient.mGet.mockImplementation(keys => [`AR:Person:{}`, `AR:Person:{}`]);
+                await Person._cachedFind([id1, id2]);
+                expect(redisClient.mGet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mGet).toHaveBeenCalledWith([`Person#find:${id1}`, `Person#find:${id2}`]);
+                expect(Person.findAll).not.toHaveBeenCalled();
+            });
+
+            it ('does hit the database when `clear` is true', async () => {
+                redisClient.mGet.mockImplementation(keys => [`AR:Person:{}`, `AR:Person:{}`]);
+                await Person._cachedFind([id1, id2], {clear: true});
+                expect(redisClient.mGet).not.toHaveBeenCalled();
+                expect(Person.findAll).toHaveBeenCalledTimes(1);
+                expect(Person.findAll).toHaveBeenCalledWith({where: {[pk]: [id1, id2]}});
+            });
+
+            it ('returns an array of active record objects if an array was passed', async () => {
+                const p1 = new Person({[pk]: id1});
+                const p2 = new Person({[pk]: id2});
+                const p3 = new Person({[pk]: id3});
+                Person.findAll.mockImplementation(() => [p1, p3]);
+                redisClient.mGet.mockImplementation(keys => [null, `AR:Person:${JSON.stringify(p2.toJSON())}`, null]);
+
+                const results = await Person._cachedFind([id1, id2, id3, id4]);
+                expect(results.length).toEqual(3);
+                expect(results).toContain(p1);
+                expect(results).toContain(p3);
+                expect(results.filter(r => r[pk] == id2).length).toEqual(1);
+            });
+
+            it ('returns a single active record object if an array was not passed', async () => {
+                const p1 = new Person({[pk]: id1});
+                Person.findAll.mockImplementation(() => [p1]);
+                const results = await Person._cachedFind(id1);
+                expect(results).toEqual(p1);
+            });
+
+            it ('sets `isNewRecord` to false for records from cache', async () => {
+                redisClient.mGet.mockImplementation(keys => [`AR:Person:{}`]);
+                const person = await Person._cachedFind(id1);
+                expect(person.options.isNewRecord).toBeFalsy();
+            });
+        });
+
+
+        describe('BaseRecord.cachedIds', () => {
+            const key     = TestHelpers.Faker.Text.randomString();
+            const colName = TestHelpers.Faker.Text.randomString();
+            const val     = TestHelpers.Faker.Text.randomString();
+            const where   = {[colName]: val};
+            const ids     = [Math.random(), Math.random(), Math.random()];
+            const pk      = Person.primaryKeyAttribute;
+            const rows    = ids.map(id => ({[pk]: id}));
+
+            it ('fetches ids from the database and sets them in cache', async () => {
+                Person.findAll.mockImplementation(() => rows);
+                await Person.cachedIds(key, where)
+                expect(redisClient.mGet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mGet).toHaveBeenCalledWith([key]);
+                expect(Person.findAll).toHaveBeenCalledTimes(1);
+                expect(Person.findAll).toHaveBeenCalledWith({ where, attributes: [pk], raw: true });
+                expect(redisClient.mSet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mSet).toHaveBeenCalledWith({
+                  [key]: JSON.stringify(ids)
+                });
+            });
+
+            it ('does not hit the database for cache hits', async () => {
+                redisClient.mGet.mockImplementation(keys => [JSON.stringify(ids)]);
+                await Person.cachedIds(key, where)
+                expect(redisClient.mGet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mGet).toHaveBeenCalledWith([key]);
+                expect(Person.findAll).not.toHaveBeenCalled();
+            });
+
+
+            it ('does hit the database when `clear` is true', async () => {
+                redisClient.mGet.mockImplementation(keys => [JSON.stringify(ids)]);
+                await Person.cachedIds(key, where, {clear: true})
+                expect(redisClient.mGet).not.toHaveBeenCalled();
+                expect(Person.findAll).toHaveBeenCalledTimes(1);
+                expect(Person.findAll).toHaveBeenCalledWith({ where, attributes: [pk], raw: true });
+            });
+
+            it ('does hit the database when `clear` is true', async () => {
+                redisClient.mGet.mockImplementation(keys => [JSON.stringify(ids)]);
+                await Person.cachedIds(key, where, {clear: true})
+                expect(redisClient.mGet).not.toHaveBeenCalled();
+                expect(Person.findAll).toHaveBeenCalledTimes(1);
+                expect(Person.findAll).toHaveBeenCalledWith({ where, attributes: [pk], raw: true });
+            });
+        });
+
+
+        describe('BaseRecord.cachedFetch', () => {
+            const key1    = Math.random();
+            const key2    = Math.random();
+            const key3    = Math.random();
+            const fetcher = jest.fn();
+
+            fetcher.mockImplementation(() => ({}));
+
+            it ('does a redis multi get with all keys', async () => {
+                await Person.cachedFetch([key1, key2, key3], {}, fetcher);
+                expect(redisClient.mGet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mGet).toHaveBeenCalledWith([key1, key2, key3]);
+            });
+
+            it ('calls the fetcher for any cache misses', async () => {
+                redisClient.mGet.mockImplementation(() => [null, '{}', null]);
+                await Person.cachedFetch([key1, key2, key3], {}, fetcher);
+                expect(fetcher).toHaveBeenCalledTimes(1);
+                expect(fetcher).toHaveBeenCalledWith([key1, key3]);
+            });
+
+            it ('does not call the fetcher if there are no cache misses', async () => {
+                redisClient.mGet.mockImplementation(() => ['{}', '{}', '{}']);
+                await Person.cachedFetch([key1, key2, key3], {}, fetcher);
+                expect(fetcher).toHaveBeenCalledTimes(0);
+            });
+
+            it ('ignores the cache if `clear` is true', async () => {
+                redisClient.mGet.mockImplementation(() => ['{}', '{}', '{}']);
+                await Person.cachedFetch([key1, key2, key3], {clear: true}, fetcher);
+                expect(redisClient.mGet).not.toHaveBeenCalled();
+                expect(fetcher).toHaveBeenCalledTimes(1);
+                expect(fetcher).toHaveBeenCalledWith([key1, key2, key3]);
+            });
+
+            it ('calls BaseRecord._cacheFetchedData with data returned by the fetcher', async () => {
+                const cacheSpy = jest.spyOn(Person, '_cacheFetchedData');
+                const obj1     = {};
+                const obj2     = {};
+                const data     = {[key1]: obj1, [key2]: obj2};
+                redisClient.mGet.mockImplementation(() => [null, null]);
+                fetcher.mockImplementation(() => data);
+
+                await Person.cachedFetch([key1, key2], {}, fetcher);
+
+                expect(cacheSpy).toHaveBeenCalledTimes(1);
+                expect(cacheSpy).toHaveBeenCalledWith(data);
+            });
+
+            it ('returns data from cache hits and misses', async () => {
+                const pk   = Person.primaryKeyAttribute;
+                const id1  = Math.random();
+                const id2  = Math.random();
+                const id3  = Math.random();
+                const obj1 = {[pk]: id1};
+                const obj2 = {[pk]: id2};
+                const obj3 = {[pk]: id3};
+                const data = {[key1]: obj1};
+                redisClient.mGet.mockImplementation(() => [null, JSON.stringify(obj2), JSON.stringify(obj3)]);
+                fetcher.mockImplementation(() => data);
+
+                const results = await Person.cachedFetch([key1, key2, key3], {}, fetcher);
+
+                expect(Object.keys(results).length).toEqual(3);
+                expect(results[key1]).toBe(obj1);
+
+                expect(results[key2]).not.toBe(obj2);
+                expect(results[key2]).toEqual(obj2);
+
+                expect(results[key3]).not.toBe(obj3);
+                expect(results[key3]).toEqual(obj3);
+            });
+        });
+
+
+        describe('BaseRecord._cacheFetchedData', () => {
+            const key1    = TestHelpers.Faker.Text.randomString();
+            const key2    = TestHelpers.Faker.Text.randomString();
+            const key3    = TestHelpers.Faker.Text.randomString();
+            const key4    = TestHelpers.Faker.Text.randomString();
+
+            it ('marshalls data and does a redis multi set', async () => {
+                const obj1Key = TestHelpers.Faker.Text.randomString();
+                const obj1Val = TestHelpers.Faker.Text.randomString();
+                const obj1 = {[obj1Key]: obj1Val};
+                const obj2Key = TestHelpers.Faker.Text.randomString();
+                const obj2Val = TestHelpers.Faker.Text.randomString();
+                const obj2 = {[obj2Key]: obj2Val};
+
+                const person1 = new Person(obj1)
+                const person2 = new Person(obj2)
+
+                await Person._cacheFetchedData({
+                    [key1]: obj1,
+                    [key2]: obj2,
+                    [key3]: person1,
+                    [key4]: person2,
+                });
+                const cachedData = {
+                    [key1]: JSON.stringify(obj1),
+                    [key2]: JSON.stringify(obj2),
+                    [key3]: `AR:Person:${JSON.stringify(obj1)}`,
+                    [key4]: `AR:Person:${JSON.stringify(obj2)}`,
+                }
+
+                expect(redisClient.mSet).toHaveBeenCalledTimes(1);
+                expect(redisClient.mSet).toHaveBeenCalledWith(cachedData);
+            });
+        });
+
+
+        describe('BaseRecord.#clearSelfCache', () => {
+            it ('deletes the key from cache', async () => {
+                const pk     = Person.primaryKeyAttribute;
+                const id     = Math.random();
+                const key    = Person._recordCacheKey(id);
+                const person = new Person({[pk]: id});
+
+                await person.clearSelfCache();
+                expect(redisClient.del).toHaveBeenCalledTimes(1);
+                expect(redisClient.del).toHaveBeenCalledWith(key);
+            });
+        });
+
+
+        describe('BaseRecord._afterSaveCacheHook', () => {
+            it ('is called as an after save hook for cached models', () => {
+                expect(Person.addHook).toHaveBeenCalledTimes(0);
+                Person.initialize();
+                expect(Person.addHook).toHaveBeenCalledTimes(1);
+                expect(Person.addHook).toHaveBeenCalledWith('afterSave', Person._afterSaveCacheHook);
+            });
+
+            it ('is not called as an after save hook for non cached models', () => {
+                class Foo extends BaseRecord {}
+                Foo.initialize();
+                expect(Person.addHook).toHaveBeenCalledTimes(0);
+            });
+
+            it ('calls BaseRecord#clearSelfCache and BaseRecord#updateCache', async () => {
+                const person    = new Person();
+                const clearSpy  = jest.spyOn(person, 'clearSelfCache');
+                const updateSpy = jest.spyOn(person, 'updateCache');
+                const options   = {};
+
+                await Person._afterSaveCacheHook(person,options);
+
+                expect(clearSpy).toHaveBeenCalledTimes(1);
+                expect(updateSpy).toHaveBeenCalledTimes(1);
+                expect(updateSpy).toHaveBeenCalledWith(options);
+            });
+        });
+    });
 });

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,
-}