gitlab-radiator 3.4.0 → 3.4.1

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); 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 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;
+  };
+}