gitlab-radiator 3.3.9 → 3.3.10

package/src/gitlab/index.js

@@ -1,53 +1,169 @@
-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
-  }
+"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);
 }
 
 function defaultBranchStatus(project, pipelines) {
-  return _(pipelines)
-    .filter({ref: project.default_branch})
-    .map('status')
-    .head()
+  return (0, _lodash.default)(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,116 +1,284 @@
-import _ from 'lodash'
-import {gitlabRequest} from './client'
+"use strict";
 
-export async function fetchLatestPipelines(projectId, gitlab) {
-  const pipelines = await fetchLatestAndMasterPipeline(projectId, gitlab)
-  const jobsForPipelines = await fetchJobsForPipelines(projectId, pipelines, gitlab)
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-  return pipelines.map(({id, ref, status}) => {
-    const jobs = matchJobs(id, jobsForPipelines)
-    return {
-      id,
-      ref,
-      status,
-      ...jobs
-    }
-  })
+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);
 }
 
-async function fetchLatestAndMasterPipeline(projectId, config) {
-  const [latestPipeline] = await fetchNonSkippedPipelines(projectId, config, {per_page: 100})
-  if (!latestPipeline) {
-    return []
-  }
-  if (latestPipeline.ref === 'master') {
-    return [latestPipeline]
-  }
-  const [latestMasterPipeline] = await fetchNonSkippedPipelines(projectId, config, {per_page: 50, ref: 'master'})
-  return [latestPipeline].concat(latestMasterPipeline || [])
+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);
 }
 
-async function fetchNonSkippedPipelines(projectId, config, options) {
-  const {data: pipelines} = await gitlabRequest(`/projects/${projectId}/pipelines`, options, config)
-  return pipelines.filter(pipeline => pipeline.status !== 'skipped')
+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);
 }
 
-// GitLab API endpoint `/projects/${projectId}/pipelines/${pipelineId}/jobs` is broken and not returning all jobs
+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
-async function fetchJobsForPipelines(projectId, pipelines, config) {
-  const includedPipelineIds = pipelines.map(pipeline => pipeline.id)
-  const [oldestCreatedAt] = pipelines.map(pipeline => pipeline.created_at).sort()
-
-  const jobs = []
-  const SAFETY_MAX_PAGE = 10
-  for (let page = 1; page <= SAFETY_MAX_PAGE; page += 1) {
-    // eslint-disable-next-line no-await-in-loop
-    const {data: jobsBatch} = await gitlabRequest(`/projects/${projectId}/jobs`, {page, per_page: 100}, config)
-    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) {
-      break
-    }
-  }
-  return jobs.flat()
+
+
+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);
+}
+
+function fetchJobsForPipelines(_x8, _x9, _x10) {
+  return _fetchJobsForPipelines.apply(this, arguments);
+}
+
+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);
 }
 
 function matchJobs(pipelineId, gitlabJobsForMultiplePipelines) {
-  const gitlabJobs = gitlabJobsForMultiplePipelines.filter(job => job.pipeline.id === pipelineId)
+  var gitlabJobs = gitlabJobsForMultiplePipelines.filter(job => job.pipeline.id === pipelineId);
+
   if (gitlabJobs.length === 0) {
-    return {}
+    return {};
   }
 
-  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()
+  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];
 
+    return {
+      name,
+      jobs: _lodash.default.sortBy(jobs, 'name')
+    };
+  }).value();
   return {
     commit,
     stages
-  }
+  };
 }
 
 function findCommit(jobs) {
-  const [job] = jobs.filter(j => j.commit)
+  var _jobs$filter = jobs.filter(j => j.commit),
+      _jobs$filter2 = (0, _slicedToArray2.default)(_jobs$filter, 1),
+      job = _jobs$filter2[0];
+
   if (!job) {
-    return null
+    return null;
   }
+
   return {
     title: job.commit.title,
     author: job.commit.author_name
-  }
+  };
 }
 
 function mergeRetriedJobs(jobs) {
   return jobs.reduce((mergedJobs, job) => {
-    const index = mergedJobs.findIndex(mergedJob => mergedJob.name === job.name)
+    var 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 _(jobs)
-    .map(job => _.omitBy(job, _.isNull))
-    .map(job => _.omit(job, 'stage'))
-    .value()
-}
+  return (0, _lodash.default)(jobs).map(job => _lodash.default.omitBy(job, _lodash.default.isNull)).map(job => _lodash.default.omit(job, 'stage')).value();
+}