gitlab-radiator 3.3.10 → 3.4.0

package/src/gitlab/index.js

@@ -1,169 +1,53 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.update = update;
-
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-
-var _lodash = _interopRequireDefault(require("lodash"));
-
-var _pipelines = require("./pipelines");
-
-var _projects = require("./projects");
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function update(_x) {
-  return _update.apply(this, arguments);
-}
-
-function _update() {
-  _update = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(config) {
-    var projectsWithPipelines;
-    return _regenerator.default.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            _context.next = 2;
-            return loadProjectsWithPipelines(config);
-
-          case 2:
-            projectsWithPipelines = _context.sent;
-            return _context.abrupt("return", projectsWithPipelines.filter(project => project.pipelines.length > 0));
-
-          case 4:
-          case "end":
-            return _context.stop();
-        }
-      }
-    }, _callee);
-  }));
-  return _update.apply(this, arguments);
-}
-
-function loadProjectsWithPipelines(_x2) {
-  return _loadProjectsWithPipelines.apply(this, arguments);
-}
-
-function _loadProjectsWithPipelines() {
-  _loadProjectsWithPipelines = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(config) {
-    var allProjectsWithPipelines;
-    return _regenerator.default.wrap(function _callee3$(_context3) {
-      while (1) {
-        switch (_context3.prev = _context3.next) {
-          case 0:
-            allProjectsWithPipelines = [];
-            _context3.next = 3;
-            return Promise.all(config.gitlabs.map( /*#__PURE__*/function () {
-              var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(gitlab) {
-                var projects, projectsWithPipelines;
-                return _regenerator.default.wrap(function _callee2$(_context2) {
-                  while (1) {
-                    switch (_context2.prev = _context2.next) {
-                      case 0:
-                        _context2.next = 2;
-                        return (0, _projects.fetchProjects)(gitlab);
-
-                      case 2:
-                        projects = _context2.sent;
-                        projects.forEach(project => {
-                          project.maxNonFailedJobsVisible = gitlab.maxNonFailedJobsVisible;
-                        });
-                        _context2.next = 6;
-                        return Promise.all(projects.map(project => projectWithPipelines(project, gitlab)));
-
-                      case 6:
-                        projectsWithPipelines = _context2.sent;
-                        allProjectsWithPipelines.push.apply(allProjectsWithPipelines, (0, _toConsumableArray2.default)(projectsWithPipelines));
-
-                      case 8:
-                      case "end":
-                        return _context2.stop();
-                    }
-                  }
-                }, _callee2);
-              }));
-
-              return function (_x5) {
-                return _ref.apply(this, arguments);
-              };
-            }()));
-
-          case 3:
-            return _context3.abrupt("return", allProjectsWithPipelines);
-
-          case 4:
-          case "end":
-            return _context3.stop();
-        }
-      }
-    }, _callee3);
-  }));
-  return _loadProjectsWithPipelines.apply(this, arguments);
-}
-
-function projectWithPipelines(_x3, _x4) {
-  return _projectWithPipelines.apply(this, arguments);
-}
-
-function _projectWithPipelines() {
-  _projectWithPipelines = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(project, config) {
-    var pipelines, status;
-    return _regenerator.default.wrap(function _callee4$(_context4) {
-      while (1) {
-        switch (_context4.prev = _context4.next) {
-          case 0:
-            _context4.t0 = filterOutEmpty;
-            _context4.next = 3;
-            return (0, _pipelines.fetchLatestPipelines)(project.id, config);
-
-          case 3:
-            _context4.t1 = _context4.sent;
-            pipelines = (0, _context4.t0)(_context4.t1).filter(excludePipelineStatusFilter(config));
-            status = defaultBranchStatus(project, pipelines);
-            return _context4.abrupt("return", _objectSpread(_objectSpread({}, project), {}, {
-              pipelines,
-              status
-            }));
-
-          case 7:
-          case "end":
-            return _context4.stop();
-        }
-      }
-    }, _callee4);
-  }));
-  return _projectWithPipelines.apply(this, arguments);
+import _ from 'lodash'
+import {fetchLatestPipelines} from './pipelines'
+import {fetchProjects} from './projects'
+
+export async function update(config) {
+  const projectsWithPipelines = await loadProjectsWithPipelines(config)
+  return projectsWithPipelines
+    .filter(project => project.pipelines.length > 0)
+}
+
+async function loadProjectsWithPipelines(config) {
+  const allProjectsWithPipelines = []
+  await Promise.all(config.gitlabs.map(async (gitlab) => {
+    const projects = await fetchProjects(gitlab)
+    projects.forEach((project) => {
+      project.maxNonFailedJobsVisible = gitlab.maxNonFailedJobsVisible
+    })
+    const projectsWithPipelines = await Promise.all(projects.map(project => projectWithPipelines(project, gitlab)))
+    allProjectsWithPipelines.push(...projectsWithPipelines)
+  }))
+  return allProjectsWithPipelines
+}
+
+async function projectWithPipelines(project, config) {
+  const pipelines = filterOutEmpty(await fetchLatestPipelines(project.id, config))
+    .filter(excludePipelineStatusFilter(config))
+  const status = defaultBranchStatus(project, pipelines)
+  return {
+    ...project,
+    pipelines,
+    status
+  }
 }
 
 function defaultBranchStatus(project, pipelines) {
-  return (0, _lodash.default)(pipelines).filter({
-    ref: project.default_branch
-  }).map('status').head();
+  return _(pipelines)
+    .filter({ref: project.default_branch})
+    .map('status')
+    .head()
 }
 
 function filterOutEmpty(pipelines) {
-  return pipelines.filter(pipeline => pipeline.stages);
+  return pipelines.filter(pipeline => pipeline.stages)
 }
 
 function excludePipelineStatusFilter(config) {
   return pipeline => {
     if (config.projects && config.projects.excludePipelineStatus) {
-      return !config.projects.excludePipelineStatus.includes(pipeline.status);
+      return !config.projects.excludePipelineStatus.includes(pipeline.status)
     }
-
-    return true;
-  };
-}
+    return true
+  }
+}

package/src/gitlab/pipelines.js

@@ -1,284 +1,117 @@
-"use strict";
+import _ from 'lodash'
+import {gitlabRequest} from './client'
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+export async function fetchLatestPipelines(projectId, gitlab) {
+  const pipelines = await fetchLatestAndMasterPipeline(projectId, gitlab)
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.fetchLatestPipelines = fetchLatestPipelines;
-
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-
-var _lodash = _interopRequireDefault(require("lodash"));
-
-var _client = require("./client");
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function fetchLatestPipelines(_x, _x2) {
-  return _fetchLatestPipelines.apply(this, arguments);
-}
-
-function _fetchLatestPipelines() {
-  _fetchLatestPipelines = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(projectId, gitlab) {
-    var pipelines, jobsForPipelines;
-    return _regenerator.default.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            _context.next = 2;
-            return fetchLatestAndMasterPipeline(projectId, gitlab);
-
-          case 2:
-            pipelines = _context.sent;
-            _context.next = 5;
-            return fetchJobsForPipelines(projectId, pipelines, gitlab);
-
-          case 5:
-            jobsForPipelines = _context.sent;
-            return _context.abrupt("return", pipelines.map(_ref3 => {
-              var id = _ref3.id,
-                  ref = _ref3.ref,
-                  status = _ref3.status;
-              var jobs = matchJobs(id, jobsForPipelines);
-              return _objectSpread({
-                id,
-                ref,
-                status
-              }, jobs);
-            }));
-
-          case 7:
-          case "end":
-            return _context.stop();
-        }
-      }
-    }, _callee);
-  }));
-  return _fetchLatestPipelines.apply(this, arguments);
-}
-
-function fetchLatestAndMasterPipeline(_x3, _x4) {
-  return _fetchLatestAndMasterPipeline.apply(this, arguments);
-}
-
-function _fetchLatestAndMasterPipeline() {
-  _fetchLatestAndMasterPipeline = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(projectId, config) {
-    var _yield$fetchNonSkippe, _yield$fetchNonSkippe2, latestPipeline, _yield$fetchNonSkippe3, _yield$fetchNonSkippe4, latestMasterPipeline;
-
-    return _regenerator.default.wrap(function _callee2$(_context2) {
-      while (1) {
-        switch (_context2.prev = _context2.next) {
-          case 0:
-            _context2.next = 2;
-            return fetchNonSkippedPipelines(projectId, config, {
-              per_page: 100
-            });
-
-          case 2:
-            _yield$fetchNonSkippe = _context2.sent;
-            _yield$fetchNonSkippe2 = (0, _slicedToArray2.default)(_yield$fetchNonSkippe, 1);
-            latestPipeline = _yield$fetchNonSkippe2[0];
-
-            if (latestPipeline) {
-              _context2.next = 7;
-              break;
-            }
-
-            return _context2.abrupt("return", []);
-
-          case 7:
-            if (!(latestPipeline.ref === 'master')) {
-              _context2.next = 9;
-              break;
-            }
-
-            return _context2.abrupt("return", [latestPipeline]);
-
-          case 9:
-            _context2.next = 11;
-            return fetchNonSkippedPipelines(projectId, config, {
-              per_page: 50,
-              ref: 'master'
-            });
-
-          case 11:
-            _yield$fetchNonSkippe3 = _context2.sent;
-            _yield$fetchNonSkippe4 = (0, _slicedToArray2.default)(_yield$fetchNonSkippe3, 1);
-            latestMasterPipeline = _yield$fetchNonSkippe4[0];
-            return _context2.abrupt("return", [latestPipeline].concat(latestMasterPipeline || []));
-
-          case 15:
-          case "end":
-            return _context2.stop();
-        }
-      }
-    }, _callee2);
-  }));
-  return _fetchLatestAndMasterPipeline.apply(this, arguments);
+  return Promise.all(pipelines.map(async ({id, ref, status}) => {
+    const {commit, stages} = await fetchJobs(projectId, id, gitlab)
+    const downstreamStages = await fetchDownstreamJobs(projectId, id, gitlab)
+    return {
+      id,
+      ref,
+      status,
+      commit,
+      stages: stages.concat(downstreamStages)
+    }
+  }))
 }
 
-function fetchNonSkippedPipelines(_x5, _x6, _x7) {
-  return _fetchNonSkippedPipelines.apply(this, arguments);
-} // GitLab API endpoint `/projects/${projectId}/pipelines/${pipelineId}/jobs` is broken and not returning all jobs
-// Need to fetch all jobs for the project (from newer to older) and match later
-
-
-function _fetchNonSkippedPipelines() {
-  _fetchNonSkippedPipelines = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(projectId, config, options) {
-    var _yield$gitlabRequest, pipelines;
-
-    return _regenerator.default.wrap(function _callee3$(_context3) {
-      while (1) {
-        switch (_context3.prev = _context3.next) {
-          case 0:
-            _context3.next = 2;
-            return (0, _client.gitlabRequest)("/projects/".concat(projectId, "/pipelines"), options, config);
-
-          case 2:
-            _yield$gitlabRequest = _context3.sent;
-            pipelines = _yield$gitlabRequest.data;
-            return _context3.abrupt("return", pipelines.filter(pipeline => pipeline.status !== 'skipped'));
-
-          case 5:
-          case "end":
-            return _context3.stop();
-        }
-      }
-    }, _callee3);
-  }));
-  return _fetchNonSkippedPipelines.apply(this, arguments);
+// eslint-disable-next-line max-statements
+async function fetchLatestAndMasterPipeline(projectId, config) {
+  const pipelines = await fetchPipelines(projectId, config, {per_page: 100})
+  if (pipelines.length === 0) {
+    return []
+  }
+  const latestPipeline = _.take(pipelines, 1)
+  if (latestPipeline[0].ref === 'master') {
+    return latestPipeline
+  }
+  const latestMasterPipeline = _(pipelines).filter({ref: 'master'}).take(1).value()
+  if (latestMasterPipeline.length > 0) {
+    return latestPipeline.concat(latestMasterPipeline)
+  }
+  const masterPipelines = await fetchPipelines(projectId, config, {per_page: 50, ref: 'master'})
+  return latestPipeline.concat(_.take(masterPipelines, 1))
 }
 
-function fetchJobsForPipelines(_x8, _x9, _x10) {
-  return _fetchJobsForPipelines.apply(this, arguments);
+async function fetchPipelines(projectId, config, options) {
+  const {data: pipelines} = await gitlabRequest(`/projects/${projectId}/pipelines`, options, config)
+  return pipelines.filter(pipeline => pipeline.status !== 'skipped')
 }
 
-function _fetchJobsForPipelines() {
-  _fetchJobsForPipelines = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(projectId, pipelines, config) {
-    var includedPipelineIds, _pipelines$map$sort, _pipelines$map$sort2, oldestCreatedAt, jobs, SAFETY_MAX_PAGE, page, _yield$gitlabRequest2, jobsBatch;
-
-    return _regenerator.default.wrap(function _callee4$(_context4) {
-      while (1) {
-        switch (_context4.prev = _context4.next) {
-          case 0:
-            includedPipelineIds = pipelines.map(pipeline => pipeline.id);
-            _pipelines$map$sort = pipelines.map(pipeline => pipeline.created_at).sort(), _pipelines$map$sort2 = (0, _slicedToArray2.default)(_pipelines$map$sort, 1), oldestCreatedAt = _pipelines$map$sort2[0];
-            jobs = [];
-            SAFETY_MAX_PAGE = 10;
-            page = 1;
-
-          case 5:
-            if (!(page <= SAFETY_MAX_PAGE)) {
-              _context4.next = 16;
-              break;
-            }
-
-            _context4.next = 8;
-            return (0, _client.gitlabRequest)("/projects/".concat(projectId, "/jobs"), {
-              page,
-              per_page: 100
-            }, config);
-
-          case 8:
-            _yield$gitlabRequest2 = _context4.sent;
-            jobsBatch = _yield$gitlabRequest2.data;
-            jobs.push(jobsBatch.filter(job => includedPipelineIds.includes(job.pipeline.id)).filter(job => job.created_at >= oldestCreatedAt));
-
-            if (!(jobsBatch.length === 0 || jobsBatch[jobsBatch.length - 1].created_at < oldestCreatedAt)) {
-              _context4.next = 13;
-              break;
-            }
-
-            return _context4.abrupt("break", 16);
-
-          case 13:
-            page += 1;
-            _context4.next = 5;
-            break;
-
-          case 16:
-            return _context4.abrupt("return", jobs.flat());
-
-          case 17:
-          case "end":
-            return _context4.stop();
-        }
-      }
-    }, _callee4);
-  }));
-  return _fetchJobsForPipelines.apply(this, arguments);
+async function fetchDownstreamJobs(projectId, pipelineId, config) {
+  const {data: gitlabBridgeJobs} = await gitlabRequest(`/projects/${projectId}/pipelines/${pipelineId}/bridges`, {per_page: 100}, config)
+  const childPipelines = gitlabBridgeJobs.filter(bridge => bridge.downstream_pipeline.status !== 'skipped')
+
+  const downstreamStages = []
+  for(const childPipeline of childPipelines) {
+    const {stages} = await fetchJobs(projectId, childPipeline.downstream_pipeline.id, config)
+    downstreamStages.push(stages.map(stage => ({
+      ...stage,
+      name: `${childPipeline.stage}:${stage.name}`
+    })))
+  }
+  return downstreamStages.flat()
 }
 
-function matchJobs(pipelineId, gitlabJobsForMultiplePipelines) {
-  var gitlabJobs = gitlabJobsForMultiplePipelines.filter(job => job.pipeline.id === pipelineId);
-
+async function fetchJobs(projectId, pipelineId, config) {
+  const {data: gitlabJobs} = await gitlabRequest(`/projects/${projectId}/pipelines/${pipelineId}/jobs?include_retried=true`, {per_page: 100}, config)
   if (gitlabJobs.length === 0) {
-    return {};
+    return {}
   }
 
-  var commit = findCommit(gitlabJobs);
-  var stages = (0, _lodash.default)(gitlabJobs).map(job => ({
-    id: job.id,
-    status: job.status,
-    stage: job.stage,
-    name: job.name,
-    startedAt: job.started_at,
-    finishedAt: job.finished_at,
-    url: job.web_url
-  })).orderBy('id').groupBy('stage').mapValues(mergeRetriedJobs).mapValues(cleanup).toPairs().map(_ref => {
-    var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
-        name = _ref2[0],
-        jobs = _ref2[1];
+  const commit = findCommit(gitlabJobs)
+  const stages = _(gitlabJobs)
+    .map(job => ({
+      id: job.id,
+      status: job.status,
+      stage: job.stage,
+      name: job.name,
+      startedAt: job.started_at,
+      finishedAt: job.finished_at,
+      url: job.web_url
+    }))
+    .orderBy('id')
+    .groupBy('stage')
+    .mapValues(mergeRetriedJobs)
+    .mapValues(cleanup)
+    .toPairs()
+    .map(([name, jobs]) => ({name, jobs: _.sortBy(jobs, 'name')}))
+    .value()
 
-    return {
-      name,
-      jobs: _lodash.default.sortBy(jobs, 'name')
-    };
-  }).value();
   return {
     commit,
     stages
-  };
+  }
 }
 
 function findCommit(jobs) {
-  var _jobs$filter = jobs.filter(j => j.commit),
-      _jobs$filter2 = (0, _slicedToArray2.default)(_jobs$filter, 1),
-      job = _jobs$filter2[0];
-
+  const [job] = jobs.filter(j => j.commit)
   if (!job) {
-    return null;
+    return null
   }
-
   return {
     title: job.commit.title,
     author: job.commit.author_name
-  };
+  }
 }
 
 function mergeRetriedJobs(jobs) {
   return jobs.reduce((mergedJobs, job) => {
-    var index = mergedJobs.findIndex(mergedJob => mergedJob.name === job.name);
-
+    const index = mergedJobs.findIndex(mergedJob => mergedJob.name === job.name)
     if (index >= 0) {
-      mergedJobs[index] = job;
+      mergedJobs[index] = job
     } else {
-      mergedJobs.push(job);
+      mergedJobs.push(job)
     }
-
-    return mergedJobs;
-  }, []);
+    return mergedJobs
+  }, [])
 }
 
 function cleanup(jobs) {
-  return (0, _lodash.default)(jobs).map(job => _lodash.default.omitBy(job, _lodash.default.isNull)).map(job => _lodash.default.omit(job, 'stage')).value();
-}
+  return _(jobs)
+    .map(job => _.omitBy(job, _.isNull))
+    .map(job => _.omit(job, 'stage'))
+    .value()
+}