gitlab-radiator 3.4.0 → 3.4.1

package/src/gitlab/pipelines.js

@@ -1,117 +1,388 @@
-import _ from 'lodash'
-import {gitlabRequest} from './client'
-
-export async function fetchLatestPipelines(projectId, gitlab) {
-  const pipelines = await fetchLatestAndMasterPipeline(projectId, gitlab)
-
-  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)
-    }
-  }))
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+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); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function fetchLatestPipelines(_x, _x2) {
+  return _fetchLatestPipelines.apply(this, arguments);
+} // eslint-disable-next-line max-statements
+
+
+function _fetchLatestPipelines() {
+  _fetchLatestPipelines = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(projectId, gitlab) {
+    var pipelines;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 2;
+            return fetchLatestAndMasterPipeline(projectId, gitlab);
+
+          case 2:
+            pipelines = _context2.sent;
+            return _context2.abrupt("return", Promise.all(pipelines.map( /*#__PURE__*/function () {
+              var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(_ref) {
+                var id, ref, status, _yield$fetchJobs, commit, stages, downstreamStages;
+
+                return _regenerator.default.wrap(function _callee$(_context) {
+                  while (1) {
+                    switch (_context.prev = _context.next) {
+                      case 0:
+                        id = _ref.id, ref = _ref.ref, status = _ref.status;
+                        _context.next = 3;
+                        return fetchJobs(projectId, id, gitlab);
+
+                      case 3:
+                        _yield$fetchJobs = _context.sent;
+                        commit = _yield$fetchJobs.commit;
+                        stages = _yield$fetchJobs.stages;
+                        _context.next = 8;
+                        return fetchDownstreamJobs(projectId, id, gitlab);
+
+                      case 8:
+                        downstreamStages = _context.sent;
+                        return _context.abrupt("return", {
+                          id,
+                          ref,
+                          status,
+                          commit,
+                          stages: stages.concat(downstreamStages)
+                        });
+
+                      case 10:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }
+                }, _callee);
+              }));
+
+              return function (_x14) {
+                return _ref2.apply(this, arguments);
+              };
+            }())));
+
+          case 4:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _fetchLatestPipelines.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 fetchLatestAndMasterPipeline(_x3, _x4) {
+  return _fetchLatestAndMasterPipeline.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 _fetchLatestAndMasterPipeline() {
+  _fetchLatestAndMasterPipeline = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(projectId, config) {
+    var pipelines, latestPipeline, latestMasterPipeline, masterPipelines;
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.next = 2;
+            return fetchPipelines(projectId, config, {
+              per_page: 100
+            });
+
+          case 2:
+            pipelines = _context3.sent;
+
+            if (!(pipelines.length === 0)) {
+              _context3.next = 5;
+              break;
+            }
+
+            return _context3.abrupt("return", []);
+
+          case 5:
+            latestPipeline = _lodash.default.take(pipelines, 1);
+
+            if (!(latestPipeline[0].ref === 'master')) {
+              _context3.next = 8;
+              break;
+            }
+
+            return _context3.abrupt("return", latestPipeline);
+
+          case 8:
+            latestMasterPipeline = (0, _lodash.default)(pipelines).filter({
+              ref: 'master'
+            }).take(1).value();
+
+            if (!(latestMasterPipeline.length > 0)) {
+              _context3.next = 11;
+              break;
+            }
+
+            return _context3.abrupt("return", latestPipeline.concat(latestMasterPipeline));
+
+          case 11:
+            _context3.next = 13;
+            return fetchPipelines(projectId, config, {
+              per_page: 50,
+              ref: 'master'
+            });
+
+          case 13:
+            masterPipelines = _context3.sent;
+            return _context3.abrupt("return", latestPipeline.concat(_lodash.default.take(masterPipelines, 1)));
+
+          case 15:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _fetchLatestAndMasterPipeline.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 fetchPipelines(_x5, _x6, _x7) {
+  return _fetchPipelines.apply(this, arguments);
 }
 
-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 {}
-  }
+function _fetchPipelines() {
+  _fetchPipelines = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(projectId, config, options) {
+    var _yield$gitlabRequest, pipelines;
 
-  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 _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            _context4.next = 2;
+            return (0, _client.gitlabRequest)("/projects/".concat(projectId, "/pipelines"), options, config);
 
-  return {
-    commit,
-    stages
-  }
+          case 2:
+            _yield$gitlabRequest = _context4.sent;
+            pipelines = _yield$gitlabRequest.data;
+            return _context4.abrupt("return", pipelines.filter(pipeline => pipeline.status !== 'skipped'));
+
+          case 5:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _fetchPipelines.apply(this, arguments);
+}
+
+function fetchDownstreamJobs(_x8, _x9, _x10) {
+  return _fetchDownstreamJobs.apply(this, arguments);
+}
+
+function _fetchDownstreamJobs() {
+  _fetchDownstreamJobs = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(projectId, pipelineId, config) {
+    var _yield$gitlabRequest2, gitlabBridgeJobs, childPipelines, downstreamStages, _iterator, _step, _loop;
+
+    return _regenerator.default.wrap(function _callee5$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            _context6.next = 2;
+            return (0, _client.gitlabRequest)("/projects/".concat(projectId, "/pipelines/").concat(pipelineId, "/bridges"), {
+              per_page: 100
+            }, config);
+
+          case 2:
+            _yield$gitlabRequest2 = _context6.sent;
+            gitlabBridgeJobs = _yield$gitlabRequest2.data;
+            childPipelines = gitlabBridgeJobs.filter(bridge => bridge.downstream_pipeline.status !== 'skipped');
+            downstreamStages = [];
+            _iterator = _createForOfIteratorHelper(childPipelines);
+            _context6.prev = 7;
+            _loop = /*#__PURE__*/_regenerator.default.mark(function _loop() {
+              var childPipeline, _yield$fetchJobs2, stages;
+
+              return _regenerator.default.wrap(function _loop$(_context5) {
+                while (1) {
+                  switch (_context5.prev = _context5.next) {
+                    case 0:
+                      childPipeline = _step.value;
+                      _context5.next = 3;
+                      return fetchJobs(projectId, childPipeline.downstream_pipeline.id, config);
+
+                    case 3:
+                      _yield$fetchJobs2 = _context5.sent;
+                      stages = _yield$fetchJobs2.stages;
+                      downstreamStages.push(stages.map(stage => _objectSpread(_objectSpread({}, stage), {}, {
+                        name: "".concat(childPipeline.stage, ":").concat(stage.name)
+                      })));
+
+                    case 6:
+                    case "end":
+                      return _context5.stop();
+                  }
+                }
+              }, _loop);
+            });
+
+            _iterator.s();
+
+          case 10:
+            if ((_step = _iterator.n()).done) {
+              _context6.next = 14;
+              break;
+            }
+
+            return _context6.delegateYield(_loop(), "t0", 12);
+
+          case 12:
+            _context6.next = 10;
+            break;
+
+          case 14:
+            _context6.next = 19;
+            break;
+
+          case 16:
+            _context6.prev = 16;
+            _context6.t1 = _context6["catch"](7);
+
+            _iterator.e(_context6.t1);
+
+          case 19:
+            _context6.prev = 19;
+
+            _iterator.f();
+
+            return _context6.finish(19);
+
+          case 22:
+            return _context6.abrupt("return", downstreamStages.flat());
+
+          case 23:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee5, null, [[7, 16, 19, 22]]);
+  }));
+  return _fetchDownstreamJobs.apply(this, arguments);
+}
+
+function fetchJobs(_x11, _x12, _x13) {
+  return _fetchJobs.apply(this, arguments);
+}
+
+function _fetchJobs() {
+  _fetchJobs = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(projectId, pipelineId, config) {
+    var _yield$gitlabRequest3, gitlabJobs, commit, stages;
+
+    return _regenerator.default.wrap(function _callee6$(_context7) {
+      while (1) {
+        switch (_context7.prev = _context7.next) {
+          case 0:
+            _context7.next = 2;
+            return (0, _client.gitlabRequest)("/projects/".concat(projectId, "/pipelines/").concat(pipelineId, "/jobs?include_retried=true"), {
+              per_page: 100
+            }, config);
+
+          case 2:
+            _yield$gitlabRequest3 = _context7.sent;
+            gitlabJobs = _yield$gitlabRequest3.data;
+
+            if (!(gitlabJobs.length === 0)) {
+              _context7.next = 6;
+              break;
+            }
+
+            return _context7.abrupt("return", {});
+
+          case 6:
+            commit = findCommit(gitlabJobs);
+            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(_ref3 => {
+              var _ref4 = (0, _slicedToArray2.default)(_ref3, 2),
+                  name = _ref4[0],
+                  jobs = _ref4[1];
+
+              return {
+                name,
+                jobs: _lodash.default.sortBy(jobs, 'name')
+              };
+            }).value();
+            return _context7.abrupt("return", {
+              commit,
+              stages
+            });
+
+          case 9:
+          case "end":
+            return _context7.stop();
+        }
+      }
+    }, _callee6);
+  }));
+  return _fetchJobs.apply(this, arguments);
 }
 
 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();
+}

package/src/gitlab/projects.js

@@ -1,28 +1,105 @@
-import {gitlabRequest} from './client'
-
-export async function fetchProjects(gitlab) {
-  const projects = await fetchOwnProjects(gitlab)
-  return projects
-    // Ignore projects for which CI/CD is not enabled
-    .filter(project => project.jobs_enabled)
-    .map(projectMapper)
-    .filter(includeRegexFilter(gitlab))
-    .filter(excludeRegexFilter(gitlab))
-    .filter(archivedFilter(gitlab))
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fetchProjects = fetchProjects;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _client = require("./client");
+
+function fetchProjects(_x) {
+  return _fetchProjects.apply(this, arguments);
 }
 
-async function fetchOwnProjects(gitlab) {
-  const projects = []
-  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, headers} = await gitlabRequest('/projects', {page, per_page: 100, membership: true}, gitlab)
-    projects.push(data)
-    if (data.length === 0 || !headers['x-next-page']) {
-      break
-    }
-  }
-  return projects.flat()
+function _fetchProjects() {
+  _fetchProjects = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(gitlab) {
+    var projects;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return fetchOwnProjects(gitlab);
+
+          case 2:
+            projects = _context.sent;
+            return _context.abrupt("return", projects // Ignore projects for which CI/CD is not enabled
+            .filter(project => project.jobs_enabled).map(projectMapper).filter(includeRegexFilter(gitlab)).filter(excludeRegexFilter(gitlab)).filter(archivedFilter(gitlab)));
+
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _fetchProjects.apply(this, arguments);
+}
+
+function fetchOwnProjects(_x2) {
+  return _fetchOwnProjects.apply(this, arguments);
+}
+
+function _fetchOwnProjects() {
+  _fetchOwnProjects = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(gitlab) {
+    var projects, SAFETY_MAX_PAGE, page, _yield$gitlabRequest, data, headers;
+
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            projects = [];
+            SAFETY_MAX_PAGE = 10;
+            page = 1;
+
+          case 3:
+            if (!(page <= SAFETY_MAX_PAGE)) {
+              _context2.next = 15;
+              break;
+            }
+
+            _context2.next = 6;
+            return (0, _client.gitlabRequest)('/projects', {
+              page,
+              per_page: 100,
+              membership: true
+            }, gitlab);
+
+          case 6:
+            _yield$gitlabRequest = _context2.sent;
+            data = _yield$gitlabRequest.data;
+            headers = _yield$gitlabRequest.headers;
+            projects.push(data);
+
+            if (!(data.length === 0 || !headers['x-next-page'])) {
+              _context2.next = 12;
+              break;
+            }
+
+            return _context2.abrupt("break", 15);
+
+          case 12:
+            page += 1;
+            _context2.next = 3;
+            break;
+
+          case 15:
+            return _context2.abrupt("return", projects.flat());
+
+          case 16:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _fetchOwnProjects.apply(this, arguments);
 }
 
 function projectMapper(project) {
@@ -35,39 +112,42 @@ function projectMapper(project) {
     default_branch: project.default_branch || 'master',
     url: project.web_url,
     tags: (project.tag_list || []).map(t => t.toLowerCase())
-  }
+  };
 }
 
 function getGroupName(project) {
-  const pathWithNameSpace = project.path_with_namespace
-  return pathWithNameSpace.split('/')[0]
+  var pathWithNameSpace = project.path_with_namespace;
+  return pathWithNameSpace.split('/')[0];
 }
 
 function includeRegexFilter(config) {
   return project => {
     if (config.projects && config.projects.include) {
-      const includeRegex = new RegExp(config.projects.include, "i")
-      return includeRegex.test(project.name)
+      var includeRegex = new RegExp(config.projects.include, "i");
+      return includeRegex.test(project.name);
     }
-    return true
-  }
+
+    return true;
+  };
 }
 
 function excludeRegexFilter(config) {
   return project => {
     if (config.projects && config.projects.exclude) {
-      const excludeRegex = new RegExp(config.projects.exclude, "i")
-      return !excludeRegex.test(project.name)
+      var excludeRegex = new RegExp(config.projects.exclude, "i");
+      return !excludeRegex.test(project.name);
     }
-    return true
-  }
+
+    return true;
+  };
 }
 
 function archivedFilter(config) {
   return project => {
     if (config.ignoreArchived) {
-      return !project.archived
+      return !project.archived;
     }
-    return true
-  }
-}
+
+    return true;
+  };
+}