jira-precommit-hook/lib/jira-operations.js

Git commit hook to verify commit messages are tagged with a JIRA issue number

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.findParent = exports.getEpicLinkField = exports.findProjectKey = undefined;

var _stringify = require('babel-runtime/core-js/json/stringify');

var _stringify2 = _interopRequireDefault(_stringify);

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var findProjectKey = exports.findProjectKey = function () {
  var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(jiraClient) {
    var projects;
    return _regenerator2.default.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.next = 2;
            return jiraClient.listProjects();

          case 2:
            projects = _context.sent;
            return _context.abrupt('return', _lodash2.default.find(projects, function (project) {
              return project.name === jiraClient.projectName;
            }).key);

          case 4:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, this);
  }));

  return function findProjectKey(_x) {
    return _ref.apply(this, arguments);
  };
}();

var handleStory = function () {
  var _ref3 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee3(jiraClient, issue) {
    var parentKey, linkField, epicIssueNumber;
    return _regenerator2.default.wrap(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            if (!issue.fields.issuelinks) {
              _context3.next = 4;
              break;
            }

            parentKey = findIssueLinkParentKey(issue);

            if (!parentKey) {
              _context3.next = 4;
              break;
            }

            return _context3.abrupt('return', jiraClient.findIssue(parentKey));

          case 4:
            _context3.next = 6;
            return getEpicLinkField(jiraClient);

          case 6:
            linkField = _context3.sent;
            epicIssueNumber = issue.fields[linkField];

            if (epicIssueNumber) {
              _context3.next = 10;
              break;
            }

            throw new Error(issue.key + ' does not have an associated parent Initiative or Epic.');

          case 10:
            return _context3.abrupt('return', jiraClient.findIssue(issue.fields[linkField]));

          case 11:
          case 'end':
            return _context3.stop();
        }
      }
    }, _callee3, this);
  }));

  return function handleStory(_x3, _x4) {
    return _ref3.apply(this, arguments);
  };
}();

exports.findIssueLinkParentKey = findIssueLinkParentKey;

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var getEpicLinkField = exports.getEpicLinkField = _lodash2.default.memoize(function () {
  var _ref2 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2(jiraClient) {
    var fields, i;
    return _regenerator2.default.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            _context2.next = 2;
            return jiraClient.listFields();

          case 2:
            fields = _context2.sent;
            i = 0;

          case 4:
            if (!(i < fields.length)) {
              _context2.next = 10;
              break;
            }

            if (!(fields[i].name === 'Epic Link')) {
              _context2.next = 7;
              break;
            }

            return _context2.abrupt('return', fields[i].id);

          case 7:
            i++;
            _context2.next = 4;
            break;

          case 10:
            throw new Error('Cannot find Epic Link Field.');

          case 11:
          case 'end':
            return _context2.stop();
        }
      }
    }, _callee2, this);
  }));

  function getEpicLinkFieldActual(_x2) {
    return _ref2.apply(this, arguments);
  }

  return getEpicLinkFieldActual;
}(), function (jiraClient) {
  return jiraClient.host;
});

function findIssueLinkParentKey(issue) {
  var result = null;
  issue.fields.issuelinks.forEach(function (issueLink) {
    if (issueLink.type.name !== 'Relates') {
      return;
    }

    var linkDirection = null;

    if (issueLink.inwardIssue) {
      linkDirection = 'inwardIssue';
    } else if (issueLink.outwardIssue) {
      linkDirection = 'outwardIssue';
    }

    if (linkDirection && issueLink[linkDirection].fields.issuetype.name === 'Initiative') {
      result = issueLink[linkDirection].key;
    }
  });

  return result;
}

function handleSubtask(jiraClient, issue) {
  return jiraClient.findIssue(issue.fields.parent.key);
}

function handleEpic(jiraClient, issue) {
  var parentKey = findIssueLinkParentKey(issue);

  if (!parentKey) {
    throw new Error('Cannot find initiative from Epic ' + issue.key + ' in issue links. ' + "Initiative should be linked by 'relates to'.");
  }

  return jiraClient.findIssue(parentKey);
}
var findParent = exports.findParent = _lodash2.default.memoize(function () {
  var _ref4 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee4(issue, jiraClient) {
    return _regenerator2.default.wrap(function _callee4$(_context4) {
      while (1) {
        switch (_context4.prev = _context4.next) {
          case 0:
            _context4.t0 = issue.fields.issuetype.name;
            _context4.next = _context4.t0 === 'Sub-task' ? 3 : _context4.t0 === 'Feature Defect' ? 3 : _context4.t0 === 'Story' ? 4 : _context4.t0 === 'Epic' ? 7 : 8;
            break;

          case 3:
            return _context4.abrupt('return', handleSubtask(jiraClient, issue));

          case 4:
            _context4.next = 6;
            return handleStory(jiraClient, issue);

          case 6:
            return _context4.abrupt('return', _context4.sent);

          case 7:
            return _context4.abrupt('return', handleEpic(jiraClient, issue));

          case 8:
            throw new Error(issue.fields.issuetype.name + ' should not have a parent.');

          case 9:
          case 'end':
            return _context4.stop();
        }
      }
    }, _callee4, this);
  }));

  function findParentActual(_x5, _x6) {
    return _ref4.apply(this, arguments);
  }

  return findParentActual;
}(), function (issue) {
  return (0, _stringify2.default)(issue);
});